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   Dali::Property::Value *result = 0 ;
16649
16650   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16651
16652   if (!jarg2) {
16653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16654     return;
16655   }
16656   std::string arg2_str(jarg2);
16657   std::string* arg2 = &arg2_str;
16658
16659   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16660
16661   {
16662     try {
16663       arg1->operator[]((std::string const &)*arg2) = *arg3;
16664     } catch (std::out_of_range& e) {
16665       {
16666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16667       };
16668     } catch (std::exception& e) {
16669       {
16670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16671       };
16672     } catch (Dali::DaliException e) {
16673       {
16674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16675       };
16676     } catch (...) {
16677       {
16678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16679       };
16680     }
16681   }
16682 }
16683
16684
16685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16686   Dali::Property::Value *result = 0 ;
16687
16688   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16689   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16690   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16691
16692   {
16693     try {
16694       arg1->operator[](arg2) = *arg3;
16695     } catch (std::out_of_range& e) {
16696       {
16697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16698       };
16699     } catch (std::exception& e) {
16700       {
16701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16702       };
16703     } catch (Dali::DaliException e) {
16704       {
16705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16706       };
16707     } catch (...) {
16708       {
16709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16710       };
16711     }
16712   }
16713 }
16714
16715
16716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16717   void * jresult ;
16718   Dali::Property::Value *result = 0 ;
16719
16720   {
16721     try {
16722       result = (Dali::Property::Value *)new Dali::Property::Value();
16723     } catch (std::out_of_range& e) {
16724       {
16725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16726       };
16727     } catch (std::exception& e) {
16728       {
16729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16730       };
16731     } catch (Dali::DaliException e) {
16732       {
16733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16734       };
16735     } catch (...) {
16736       {
16737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16738       };
16739     }
16740   }
16741
16742   jresult = (void *)result;
16743   return jresult;
16744 }
16745
16746
16747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16748   void * jresult ;
16749   bool arg1 ;
16750   Dali::Property::Value *result = 0 ;
16751
16752   arg1 = jarg1 ? true : false;
16753   {
16754     try {
16755       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16756     } catch (std::out_of_range& e) {
16757       {
16758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16759       };
16760     } catch (std::exception& e) {
16761       {
16762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16763       };
16764     } catch (Dali::DaliException e) {
16765       {
16766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16767       };
16768     } catch (...) {
16769       {
16770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16771       };
16772     }
16773   }
16774
16775   jresult = (void *)result;
16776   return jresult;
16777 }
16778
16779
16780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16781   void * jresult ;
16782   int arg1 ;
16783   Dali::Property::Value *result = 0 ;
16784
16785   arg1 = (int)jarg1;
16786   {
16787     try {
16788       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16789     } catch (std::out_of_range& e) {
16790       {
16791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16792       };
16793     } catch (std::exception& e) {
16794       {
16795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16796       };
16797     } catch (Dali::DaliException e) {
16798       {
16799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16800       };
16801     } catch (...) {
16802       {
16803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16804       };
16805     }
16806   }
16807
16808   jresult = (void *)result;
16809   return jresult;
16810 }
16811
16812
16813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16814   void * jresult ;
16815   float arg1 ;
16816   Dali::Property::Value *result = 0 ;
16817
16818   arg1 = (float)jarg1;
16819   {
16820     try {
16821       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16822     } catch (std::out_of_range& e) {
16823       {
16824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16825       };
16826     } catch (std::exception& e) {
16827       {
16828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16829       };
16830     } catch (Dali::DaliException e) {
16831       {
16832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16833       };
16834     } catch (...) {
16835       {
16836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16837       };
16838     }
16839   }
16840
16841   jresult = (void *)result;
16842   return jresult;
16843 }
16844
16845
16846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16847   void * jresult ;
16848   Dali::Vector2 *arg1 = 0 ;
16849   Dali::Property::Value *result = 0 ;
16850
16851   arg1 = (Dali::Vector2 *)jarg1;
16852   if (!arg1) {
16853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16854     return 0;
16855   }
16856   {
16857     try {
16858       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16859     } catch (std::out_of_range& e) {
16860       {
16861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16862       };
16863     } catch (std::exception& e) {
16864       {
16865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16866       };
16867     } catch (Dali::DaliException e) {
16868       {
16869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16870       };
16871     } catch (...) {
16872       {
16873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16874       };
16875     }
16876   }
16877
16878   jresult = (void *)result;
16879   return jresult;
16880 }
16881
16882
16883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16884   void * jresult ;
16885   Dali::Vector3 *arg1 = 0 ;
16886   Dali::Property::Value *result = 0 ;
16887
16888   arg1 = (Dali::Vector3 *)jarg1;
16889   if (!arg1) {
16890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16891     return 0;
16892   }
16893   {
16894     try {
16895       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16896     } catch (std::out_of_range& e) {
16897       {
16898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16899       };
16900     } catch (std::exception& e) {
16901       {
16902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16903       };
16904     } catch (Dali::DaliException e) {
16905       {
16906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16907       };
16908     } catch (...) {
16909       {
16910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16911       };
16912     }
16913   }
16914
16915   jresult = (void *)result;
16916   return jresult;
16917 }
16918
16919
16920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16921   void * jresult ;
16922   Dali::Vector4 *arg1 = 0 ;
16923   Dali::Property::Value *result = 0 ;
16924
16925   arg1 = (Dali::Vector4 *)jarg1;
16926   if (!arg1) {
16927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16928     return 0;
16929   }
16930   {
16931     try {
16932       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16933     } catch (std::out_of_range& e) {
16934       {
16935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16936       };
16937     } catch (std::exception& e) {
16938       {
16939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16940       };
16941     } catch (Dali::DaliException e) {
16942       {
16943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16944       };
16945     } catch (...) {
16946       {
16947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16948       };
16949     }
16950   }
16951
16952   jresult = (void *)result;
16953   return jresult;
16954 }
16955
16956
16957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16958   void * jresult ;
16959   Dali::Matrix3 *arg1 = 0 ;
16960   Dali::Property::Value *result = 0 ;
16961
16962   arg1 = (Dali::Matrix3 *)jarg1;
16963   if (!arg1) {
16964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16965     return 0;
16966   }
16967   {
16968     try {
16969       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16970     } catch (std::out_of_range& e) {
16971       {
16972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16973       };
16974     } catch (std::exception& e) {
16975       {
16976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16977       };
16978     } catch (Dali::DaliException e) {
16979       {
16980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16981       };
16982     } catch (...) {
16983       {
16984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16985       };
16986     }
16987   }
16988
16989   jresult = (void *)result;
16990   return jresult;
16991 }
16992
16993
16994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16995   void * jresult ;
16996   Dali::Matrix *arg1 = 0 ;
16997   Dali::Property::Value *result = 0 ;
16998
16999   arg1 = (Dali::Matrix *)jarg1;
17000   if (!arg1) {
17001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
17002     return 0;
17003   }
17004   {
17005     try {
17006       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
17007     } catch (std::out_of_range& e) {
17008       {
17009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17010       };
17011     } catch (std::exception& e) {
17012       {
17013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17014       };
17015     } catch (Dali::DaliException e) {
17016       {
17017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17018       };
17019     } catch (...) {
17020       {
17021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17022       };
17023     }
17024   }
17025
17026   jresult = (void *)result;
17027   return jresult;
17028 }
17029
17030
17031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
17032   void * jresult ;
17033   Dali::Rect< int > *arg1 = 0 ;
17034   Dali::Property::Value *result = 0 ;
17035
17036   arg1 = (Dali::Rect< int > *)jarg1;
17037   if (!arg1) {
17038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17039     return 0;
17040   }
17041   {
17042     try {
17043       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17044     } catch (std::out_of_range& e) {
17045       {
17046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17047       };
17048     } catch (std::exception& e) {
17049       {
17050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17051       };
17052     } catch (Dali::DaliException e) {
17053       {
17054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17055       };
17056     } catch (...) {
17057       {
17058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17059       };
17060     }
17061   }
17062
17063   jresult = (void *)result;
17064   return jresult;
17065 }
17066
17067
17068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17069   void * jresult ;
17070   Dali::AngleAxis *arg1 = 0 ;
17071   Dali::Property::Value *result = 0 ;
17072
17073   arg1 = (Dali::AngleAxis *)jarg1;
17074   if (!arg1) {
17075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17076     return 0;
17077   }
17078   {
17079     try {
17080       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17081     } catch (std::out_of_range& e) {
17082       {
17083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17084       };
17085     } catch (std::exception& e) {
17086       {
17087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17088       };
17089     } catch (Dali::DaliException e) {
17090       {
17091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17092       };
17093     } catch (...) {
17094       {
17095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17096       };
17097     }
17098   }
17099
17100   jresult = (void *)result;
17101   return jresult;
17102 }
17103
17104
17105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17106   void * jresult ;
17107   Dali::Quaternion *arg1 = 0 ;
17108   Dali::Property::Value *result = 0 ;
17109
17110   arg1 = (Dali::Quaternion *)jarg1;
17111   if (!arg1) {
17112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17113     return 0;
17114   }
17115   {
17116     try {
17117       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17118     } catch (std::out_of_range& e) {
17119       {
17120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17121       };
17122     } catch (std::exception& e) {
17123       {
17124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17125       };
17126     } catch (Dali::DaliException e) {
17127       {
17128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17129       };
17130     } catch (...) {
17131       {
17132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17133       };
17134     }
17135   }
17136
17137   jresult = (void *)result;
17138   return jresult;
17139 }
17140
17141
17142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17143   void * jresult ;
17144   std::string *arg1 = 0 ;
17145   Dali::Property::Value *result = 0 ;
17146
17147   if (!jarg1) {
17148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17149     return 0;
17150   }
17151   std::string arg1_str(jarg1);
17152   arg1 = &arg1_str;
17153   {
17154     try {
17155       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17156     } catch (std::out_of_range& e) {
17157       {
17158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17159       };
17160     } catch (std::exception& e) {
17161       {
17162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17163       };
17164     } catch (Dali::DaliException e) {
17165       {
17166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17167       };
17168     } catch (...) {
17169       {
17170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17171       };
17172     }
17173   }
17174
17175   jresult = (void *)result;
17176
17177   //argout typemap for const std::string&
17178
17179   return jresult;
17180 }
17181
17182
17183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17184   void * jresult ;
17185   Dali::Property::Array *arg1 = 0 ;
17186   Dali::Property::Value *result = 0 ;
17187
17188   arg1 = (Dali::Property::Array *)jarg1;
17189   if (!arg1) {
17190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17191     return 0;
17192   }
17193   {
17194     try {
17195       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17196     } catch (std::out_of_range& e) {
17197       {
17198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17199       };
17200     } catch (std::exception& e) {
17201       {
17202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17203       };
17204     } catch (Dali::DaliException e) {
17205       {
17206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17207       };
17208     } catch (...) {
17209       {
17210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17211       };
17212     }
17213   }
17214
17215   jresult = (void *)result;
17216   return jresult;
17217 }
17218
17219
17220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17221   void * jresult ;
17222   Dali::Property::Map *arg1 = 0 ;
17223   Dali::Property::Value *result = 0 ;
17224
17225   arg1 = (Dali::Property::Map *)jarg1;
17226   if (!arg1) {
17227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17228     return 0;
17229   }
17230   {
17231     try {
17232       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17233     } catch (std::out_of_range& e) {
17234       {
17235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17236       };
17237     } catch (std::exception& e) {
17238       {
17239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17240       };
17241     } catch (Dali::DaliException e) {
17242       {
17243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17244       };
17245     } catch (...) {
17246       {
17247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17248       };
17249     }
17250   }
17251
17252   jresult = (void *)result;
17253   return jresult;
17254 }
17255
17256
17257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17258   void * jresult ;
17259   Extents *arg1 = 0 ;
17260   Dali::Property::Value *result = 0 ;
17261
17262   arg1 = (Extents *)jarg1;
17263   if (!arg1) {
17264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17265     return 0;
17266   }
17267   {
17268     try {
17269       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17270     } catch (std::out_of_range& e) {
17271       {
17272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17273       };
17274     } catch (std::exception& e) {
17275       {
17276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17277       };
17278     } catch (...) {
17279       {
17280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17281       };
17282     }
17283   }
17284   jresult = (void *)result;
17285   return jresult;
17286 }
17287
17288
17289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17290   void * jresult ;
17291   Dali::Property::Type arg1 ;
17292   Dali::Property::Value *result = 0 ;
17293
17294   arg1 = (Dali::Property::Type)jarg1;
17295   {
17296     try {
17297       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17298     } catch (std::out_of_range& e) {
17299       {
17300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17301       };
17302     } catch (std::exception& e) {
17303       {
17304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17305       };
17306     } catch (Dali::DaliException e) {
17307       {
17308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17309       };
17310     } catch (...) {
17311       {
17312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17313       };
17314     }
17315   }
17316
17317   jresult = (void *)result;
17318   return jresult;
17319 }
17320
17321
17322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17323   void * jresult ;
17324   Dali::Property::Value *arg1 = 0 ;
17325   Dali::Property::Value *result = 0 ;
17326
17327   arg1 = (Dali::Property::Value *)jarg1;
17328   if (!arg1) {
17329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17330     return 0;
17331   }
17332   {
17333     try {
17334       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17335     } catch (std::out_of_range& e) {
17336       {
17337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17338       };
17339     } catch (std::exception& e) {
17340       {
17341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17342       };
17343     } catch (Dali::DaliException e) {
17344       {
17345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17346       };
17347     } catch (...) {
17348       {
17349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17350       };
17351     }
17352   }
17353
17354   jresult = (void *)result;
17355   return jresult;
17356 }
17357
17358
17359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17360   void * jresult ;
17361   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17362   Dali::Property::Value *arg2 = 0 ;
17363   Dali::Property::Value *result = 0 ;
17364
17365   arg1 = (Dali::Property::Value *)jarg1;
17366   arg2 = (Dali::Property::Value *)jarg2;
17367   if (!arg2) {
17368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17369     return 0;
17370   }
17371   {
17372     try {
17373       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17374     } catch (std::out_of_range& e) {
17375       {
17376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17377       };
17378     } catch (std::exception& e) {
17379       {
17380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17381       };
17382     } catch (Dali::DaliException e) {
17383       {
17384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17385       };
17386     } catch (...) {
17387       {
17388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17389       };
17390     }
17391   }
17392
17393   jresult = (void *)result;
17394   return jresult;
17395 }
17396
17397
17398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17399   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17400
17401   arg1 = (Dali::Property::Value *)jarg1;
17402   {
17403     try {
17404       delete arg1;
17405     } catch (std::out_of_range& e) {
17406       {
17407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17408       };
17409     } catch (std::exception& e) {
17410       {
17411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17412       };
17413     } catch (Dali::DaliException e) {
17414       {
17415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17416       };
17417     } catch (...) {
17418       {
17419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17420       };
17421     }
17422   }
17423
17424 }
17425
17426
17427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17428   int jresult ;
17429   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17430   Dali::Property::Type result;
17431
17432   arg1 = (Dali::Property::Value *)jarg1;
17433   {
17434     try {
17435       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17436     } catch (std::out_of_range& e) {
17437       {
17438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17439       };
17440     } catch (std::exception& e) {
17441       {
17442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17443       };
17444     } catch (Dali::DaliException e) {
17445       {
17446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17447       };
17448     } catch (...) {
17449       {
17450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17451       };
17452     }
17453   }
17454
17455   jresult = (int)result;
17456   return jresult;
17457 }
17458
17459
17460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17461   unsigned int jresult ;
17462   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17463   bool *arg2 = 0 ;
17464   bool result;
17465
17466   arg1 = (Dali::Property::Value *)jarg1;
17467   arg2 = (bool *)jarg2;
17468   {
17469     try {
17470       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17471     } catch (std::out_of_range& e) {
17472       {
17473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17474       };
17475     } catch (std::exception& e) {
17476       {
17477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17478       };
17479     } catch (Dali::DaliException e) {
17480       {
17481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17482       };
17483     } catch (...) {
17484       {
17485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17486       };
17487     }
17488   }
17489
17490   jresult = result;
17491   return jresult;
17492 }
17493
17494
17495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17496   unsigned int jresult ;
17497   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17498   float *arg2 = 0 ;
17499   bool result;
17500
17501   arg1 = (Dali::Property::Value *)jarg1;
17502   arg2 = (float *)jarg2;
17503   {
17504     try {
17505       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17506     } catch (std::out_of_range& e) {
17507       {
17508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17509       };
17510     } catch (std::exception& e) {
17511       {
17512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17513       };
17514     } catch (Dali::DaliException e) {
17515       {
17516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17517       };
17518     } catch (...) {
17519       {
17520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17521       };
17522     }
17523   }
17524
17525   jresult = result;
17526   return jresult;
17527 }
17528
17529
17530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17531   unsigned int jresult ;
17532   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17533   int *arg2 = 0 ;
17534   bool result;
17535
17536   arg1 = (Dali::Property::Value *)jarg1;
17537   arg2 = (int *)jarg2;
17538   {
17539     try {
17540       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17541     } catch (std::out_of_range& e) {
17542       {
17543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17544       };
17545     } catch (std::exception& e) {
17546       {
17547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17548       };
17549     } catch (Dali::DaliException e) {
17550       {
17551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17552       };
17553     } catch (...) {
17554       {
17555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17556       };
17557     }
17558   }
17559
17560   jresult = result;
17561   return jresult;
17562 }
17563
17564
17565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17566   unsigned int jresult ;
17567   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17568   Dali::Rect< int > *arg2 = 0 ;
17569   bool result;
17570
17571   arg1 = (Dali::Property::Value *)jarg1;
17572   arg2 = (Dali::Rect< int > *)jarg2;
17573   if (!arg2) {
17574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17575     return 0;
17576   }
17577   {
17578     try {
17579       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17580     } catch (std::out_of_range& e) {
17581       {
17582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17583       };
17584     } catch (std::exception& e) {
17585       {
17586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17587       };
17588     } catch (Dali::DaliException e) {
17589       {
17590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17591       };
17592     } catch (...) {
17593       {
17594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17595       };
17596     }
17597   }
17598
17599   jresult = result;
17600   return jresult;
17601 }
17602
17603
17604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17605   unsigned int jresult ;
17606   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17607   Dali::Vector2 *arg2 = 0 ;
17608   bool result;
17609
17610   arg1 = (Dali::Property::Value *)jarg1;
17611   arg2 = (Dali::Vector2 *)jarg2;
17612   if (!arg2) {
17613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17614     return 0;
17615   }
17616   {
17617     try {
17618       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17619     } catch (std::out_of_range& e) {
17620       {
17621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17622       };
17623     } catch (std::exception& e) {
17624       {
17625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17626       };
17627     } catch (Dali::DaliException e) {
17628       {
17629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17630       };
17631     } catch (...) {
17632       {
17633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17634       };
17635     }
17636   }
17637
17638   jresult = result;
17639   return jresult;
17640 }
17641
17642
17643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17644   unsigned int jresult ;
17645   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17646   Dali::Vector3 *arg2 = 0 ;
17647   bool result;
17648
17649   arg1 = (Dali::Property::Value *)jarg1;
17650   arg2 = (Dali::Vector3 *)jarg2;
17651   if (!arg2) {
17652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17653     return 0;
17654   }
17655   {
17656     try {
17657       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17658     } catch (std::out_of_range& e) {
17659       {
17660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17661       };
17662     } catch (std::exception& e) {
17663       {
17664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17665       };
17666     } catch (Dali::DaliException e) {
17667       {
17668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17669       };
17670     } catch (...) {
17671       {
17672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17673       };
17674     }
17675   }
17676
17677   jresult = result;
17678   return jresult;
17679 }
17680
17681
17682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17683   unsigned int jresult ;
17684   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17685   Dali::Vector4 *arg2 = 0 ;
17686   bool result;
17687
17688   arg1 = (Dali::Property::Value *)jarg1;
17689   arg2 = (Dali::Vector4 *)jarg2;
17690   if (!arg2) {
17691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17692     return 0;
17693   }
17694   {
17695     try {
17696       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17697     } catch (std::out_of_range& e) {
17698       {
17699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17700       };
17701     } catch (std::exception& e) {
17702       {
17703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17704       };
17705     } catch (Dali::DaliException e) {
17706       {
17707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17708       };
17709     } catch (...) {
17710       {
17711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17712       };
17713     }
17714   }
17715
17716   jresult = result;
17717   return jresult;
17718 }
17719
17720
17721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17722   unsigned int jresult ;
17723   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17724   Dali::Matrix3 *arg2 = 0 ;
17725   bool result;
17726
17727   arg1 = (Dali::Property::Value *)jarg1;
17728   arg2 = (Dali::Matrix3 *)jarg2;
17729   if (!arg2) {
17730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17731     return 0;
17732   }
17733   {
17734     try {
17735       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17736     } catch (std::out_of_range& e) {
17737       {
17738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17739       };
17740     } catch (std::exception& e) {
17741       {
17742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17743       };
17744     } catch (Dali::DaliException e) {
17745       {
17746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17747       };
17748     } catch (...) {
17749       {
17750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17751       };
17752     }
17753   }
17754
17755   jresult = result;
17756   return jresult;
17757 }
17758
17759
17760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17761   unsigned int jresult ;
17762   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17763   Dali::Matrix *arg2 = 0 ;
17764   bool result;
17765
17766   arg1 = (Dali::Property::Value *)jarg1;
17767   arg2 = (Dali::Matrix *)jarg2;
17768   if (!arg2) {
17769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17770     return 0;
17771   }
17772   {
17773     try {
17774       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17775     } catch (std::out_of_range& e) {
17776       {
17777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17778       };
17779     } catch (std::exception& e) {
17780       {
17781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17782       };
17783     } catch (Dali::DaliException e) {
17784       {
17785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17786       };
17787     } catch (...) {
17788       {
17789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17790       };
17791     }
17792   }
17793
17794   jresult = result;
17795   return jresult;
17796 }
17797
17798
17799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17800   unsigned int jresult ;
17801   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17802   Dali::AngleAxis *arg2 = 0 ;
17803   bool result;
17804
17805   arg1 = (Dali::Property::Value *)jarg1;
17806   arg2 = (Dali::AngleAxis *)jarg2;
17807   if (!arg2) {
17808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17809     return 0;
17810   }
17811   {
17812     try {
17813       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17814     } catch (std::out_of_range& e) {
17815       {
17816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17817       };
17818     } catch (std::exception& e) {
17819       {
17820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17821       };
17822     } catch (Dali::DaliException e) {
17823       {
17824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17825       };
17826     } catch (...) {
17827       {
17828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17829       };
17830     }
17831   }
17832
17833   jresult = result;
17834   return jresult;
17835 }
17836
17837
17838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17839   unsigned int jresult ;
17840   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17841   Dali::Quaternion *arg2 = 0 ;
17842   bool result;
17843
17844   arg1 = (Dali::Property::Value *)jarg1;
17845   arg2 = (Dali::Quaternion *)jarg2;
17846   if (!arg2) {
17847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17848     return 0;
17849   }
17850   {
17851     try {
17852       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17853     } catch (std::out_of_range& e) {
17854       {
17855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17856       };
17857     } catch (std::exception& e) {
17858       {
17859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17860       };
17861     } catch (Dali::DaliException e) {
17862       {
17863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17864       };
17865     } catch (...) {
17866       {
17867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17868       };
17869     }
17870   }
17871
17872   jresult = result;
17873   return jresult;
17874 }
17875
17876
17877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17878   unsigned int jresult ;
17879   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17880   std::string *arg2 = 0 ;
17881   bool result;
17882
17883   arg1 = (Dali::Property::Value *)jarg1;
17884
17885   //typemap in
17886   std::string temp;
17887   arg2 = &temp;
17888
17889   {
17890     try {
17891       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17892     } catch (std::out_of_range& e) {
17893       {
17894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17895       };
17896     } catch (std::exception& e) {
17897       {
17898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17899       };
17900     } catch (Dali::DaliException e) {
17901       {
17902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17903       };
17904     } catch (...) {
17905       {
17906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17907       };
17908     }
17909   }
17910
17911   jresult = result;
17912
17913   //Typemap argout in c++ file.
17914   //This will convert c++ string to c# string
17915   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17916
17917   return jresult;
17918 }
17919
17920
17921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17922   unsigned int jresult ;
17923   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17924   Dali::Property::Array *arg2 = 0 ;
17925   bool result;
17926
17927   arg1 = (Dali::Property::Value *)jarg1;
17928   arg2 = (Dali::Property::Array *)jarg2;
17929   if (!arg2) {
17930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17931     return 0;
17932   }
17933   {
17934     try {
17935       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17936     } catch (std::out_of_range& e) {
17937       {
17938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17939       };
17940     } catch (std::exception& e) {
17941       {
17942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17943       };
17944     } catch (Dali::DaliException e) {
17945       {
17946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17947       };
17948     } catch (...) {
17949       {
17950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17951       };
17952     }
17953   }
17954
17955   jresult = result;
17956   return jresult;
17957 }
17958
17959
17960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17961   unsigned int jresult ;
17962   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17963   Dali::Property::Map *arg2 = 0 ;
17964   bool result;
17965
17966   arg1 = (Dali::Property::Value *)jarg1;
17967   arg2 = (Dali::Property::Map *)jarg2;
17968   if (!arg2) {
17969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17970     return 0;
17971   }
17972   {
17973     try {
17974       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17975     } catch (std::out_of_range& e) {
17976       {
17977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17978       };
17979     } catch (std::exception& e) {
17980       {
17981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17982       };
17983     } catch (Dali::DaliException e) {
17984       {
17985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17986       };
17987     } catch (...) {
17988       {
17989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17990       };
17991     }
17992   }
17993
17994   jresult = result;
17995   return jresult;
17996 }
17997
17998
17999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
18000   unsigned int jresult ;
18001   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18002   Extents *arg2 = 0 ;
18003   bool result;
18004
18005   arg1 = (Dali::Property::Value *)jarg1;
18006   arg2 = (Extents *)jarg2;
18007   if (!arg2) {
18008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
18009     return 0;
18010   }
18011   {
18012     try {
18013       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
18014     } catch (std::out_of_range& e) {
18015       {
18016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18017       };
18018     } catch (std::exception& e) {
18019       {
18020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18021       };
18022     } catch (...) {
18023       {
18024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18025       };
18026     }
18027   }
18028   jresult = result;
18029   return jresult;
18030 }
18031
18032
18033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
18034   void * jresult ;
18035   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18036   Dali::Property::Array *result = 0 ;
18037
18038   arg1 = (Dali::Property::Value *)jarg1;
18039   {
18040     try {
18041       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18042     } catch (std::out_of_range& e) {
18043       {
18044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18045       };
18046     } catch (std::exception& e) {
18047       {
18048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18049       };
18050     } catch (Dali::DaliException e) {
18051       {
18052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18053       };
18054     } catch (...) {
18055       {
18056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18057       };
18058     }
18059   }
18060
18061   jresult = (void *)result;
18062   return jresult;
18063 }
18064
18065
18066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18067   void * jresult ;
18068   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18069   Dali::Property::Map *result = 0 ;
18070
18071   arg1 = (Dali::Property::Value *)jarg1;
18072   {
18073     try {
18074       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18075     } catch (std::out_of_range& e) {
18076       {
18077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18078       };
18079     } catch (std::exception& e) {
18080       {
18081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18082       };
18083     } catch (Dali::DaliException e) {
18084       {
18085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18086       };
18087     } catch (...) {
18088       {
18089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18090       };
18091     }
18092   }
18093
18094   jresult = (void *)result;
18095   return jresult;
18096 }
18097
18098
18099 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18100   char * jresult ;
18101   Dali::Property::Type arg1 ;
18102   char *result = 0 ;
18103
18104   arg1 = (Dali::Property::Type)jarg1;
18105   {
18106     try {
18107       result = (char *)Dali::PropertyTypes::GetName(arg1);
18108     } catch (std::out_of_range& e) {
18109       {
18110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18111       };
18112     } catch (std::exception& e) {
18113       {
18114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18115       };
18116     } catch (Dali::DaliException e) {
18117       {
18118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18119       };
18120     } catch (...) {
18121       {
18122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18123       };
18124     }
18125   }
18126
18127   jresult = SWIG_csharp_string_callback((const char *)result);
18128   return jresult;
18129 }
18130
18131
18132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18133   unsigned int jresult ;
18134   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18135   std::string *arg2 = 0 ;
18136   Dali::Property::Map *arg3 = 0 ;
18137   bool result;
18138
18139   arg1 = (Dali::BaseObject *)jarg1;
18140   if (!jarg2) {
18141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18142     return 0;
18143   }
18144   std::string arg2_str(jarg2);
18145   arg2 = &arg2_str;
18146   arg3 = (Dali::Property::Map *)jarg3;
18147   if (!arg3) {
18148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18149     return 0;
18150   }
18151   {
18152     try {
18153       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18154     } catch (std::out_of_range& e) {
18155       {
18156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18157       };
18158     } catch (std::exception& e) {
18159       {
18160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18161       };
18162     } catch (Dali::DaliException e) {
18163       {
18164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18165       };
18166     } catch (...) {
18167       {
18168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18169       };
18170     }
18171   }
18172
18173   jresult = result;
18174
18175   //argout typemap for const std::string&
18176
18177   return jresult;
18178 }
18179
18180
18181 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18182   char * jresult ;
18183   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18184   std::string *result = 0 ;
18185
18186   arg1 = (Dali::BaseObject *)jarg1;
18187   {
18188     try {
18189       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18190     } catch (std::out_of_range& e) {
18191       {
18192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18193       };
18194     } catch (std::exception& e) {
18195       {
18196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18197       };
18198     } catch (Dali::DaliException e) {
18199       {
18200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18201       };
18202     } catch (...) {
18203       {
18204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18205       };
18206     }
18207   }
18208
18209   jresult = SWIG_csharp_string_callback(result->c_str());
18210   return jresult;
18211 }
18212
18213
18214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18215   unsigned int jresult ;
18216   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18217   Dali::TypeInfo *arg2 = 0 ;
18218   bool result;
18219
18220   arg1 = (Dali::BaseObject *)jarg1;
18221   arg2 = (Dali::TypeInfo *)jarg2;
18222   if (!arg2) {
18223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18224     return 0;
18225   }
18226   {
18227     try {
18228       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18229     } catch (std::out_of_range& e) {
18230       {
18231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18232       };
18233     } catch (std::exception& e) {
18234       {
18235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18236       };
18237     } catch (Dali::DaliException e) {
18238       {
18239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18240       };
18241     } catch (...) {
18242       {
18243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18244       };
18245     }
18246   }
18247
18248   jresult = result;
18249   return jresult;
18250 }
18251
18252
18253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18254   unsigned int jresult ;
18255   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18256   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18257   std::string *arg3 = 0 ;
18258   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18259   bool result;
18260
18261   arg1 = (Dali::BaseObject *)jarg1;
18262   arg2 = (ConnectionTrackerInterface *)jarg2;
18263   if (!jarg3) {
18264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18265     return 0;
18266   }
18267   std::string arg3_str(jarg3);
18268   arg3 = &arg3_str;
18269   arg4 = (FunctorDelegate *)jarg4;
18270   {
18271     try {
18272       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18273     } catch (std::out_of_range& e) {
18274       {
18275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18276       };
18277     } catch (std::exception& e) {
18278       {
18279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18280       };
18281     } catch (Dali::DaliException e) {
18282       {
18283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18284       };
18285     } catch (...) {
18286       {
18287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18288       };
18289     }
18290   }
18291
18292   jresult = result;
18293
18294   //argout typemap for const std::string&
18295
18296   return jresult;
18297 }
18298
18299
18300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18301   void * jresult ;
18302   Dali::BaseHandle *arg1 = 0 ;
18303   Dali::BaseObject *result = 0 ;
18304
18305   arg1 = (Dali::BaseHandle *)jarg1;
18306   if (!arg1) {
18307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18308     return 0;
18309   }
18310   {
18311     try {
18312       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18313     } catch (std::out_of_range& e) {
18314       {
18315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18316       };
18317     } catch (std::exception& e) {
18318       {
18319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18320       };
18321     } catch (Dali::DaliException e) {
18322       {
18323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18324       };
18325     } catch (...) {
18326       {
18327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18328       };
18329     }
18330   }
18331
18332   jresult = (void *)result;
18333   return jresult;
18334 }
18335
18336
18337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18338   void * jresult ;
18339   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18340   Dali::BaseHandle *result = 0 ;
18341
18342   arg1 = (Dali::BaseObject *)jarg1;
18343   {
18344     try {
18345       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18346     } catch (std::out_of_range& e) {
18347       {
18348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18349       };
18350     } catch (std::exception& e) {
18351       {
18352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18353       };
18354     } catch (Dali::DaliException e) {
18355       {
18356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18357       };
18358     } catch (...) {
18359       {
18360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18361       };
18362     }
18363   }
18364
18365   jresult = (void *)result;
18366   return jresult;
18367 }
18368
18369
18370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18371   void * jresult ;
18372   Dali::BaseHandle *result = 0 ;
18373
18374   {
18375     try {
18376       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18377     } catch (std::out_of_range& e) {
18378       {
18379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18380       };
18381     } catch (std::exception& e) {
18382       {
18383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18384       };
18385     } catch (Dali::DaliException e) {
18386       {
18387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18388       };
18389     } catch (...) {
18390       {
18391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18392       };
18393     }
18394   }
18395
18396   jresult = (void *)result;
18397   return jresult;
18398 }
18399
18400
18401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18402   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18403
18404   arg1 = (Dali::BaseHandle *)jarg1;
18405   {
18406     try {
18407       delete arg1;
18408     } catch (std::out_of_range& e) {
18409       {
18410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18411       };
18412     } catch (std::exception& e) {
18413       {
18414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18415       };
18416     } catch (Dali::DaliException e) {
18417       {
18418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18419       };
18420     } catch (...) {
18421       {
18422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18423       };
18424     }
18425   }
18426
18427 }
18428
18429
18430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18431   void * jresult ;
18432   Dali::BaseHandle *arg1 = 0 ;
18433   Dali::BaseHandle *result = 0 ;
18434
18435   arg1 = (Dali::BaseHandle *)jarg1;
18436   if (!arg1) {
18437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18438     return 0;
18439   }
18440   {
18441     try {
18442       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18443     } catch (std::out_of_range& e) {
18444       {
18445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18446       };
18447     } catch (std::exception& e) {
18448       {
18449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18450       };
18451     } catch (Dali::DaliException e) {
18452       {
18453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18454       };
18455     } catch (...) {
18456       {
18457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18458       };
18459     }
18460   }
18461
18462   jresult = (void *)result;
18463   return jresult;
18464 }
18465
18466
18467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18468   void * jresult ;
18469   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18470   Dali::BaseHandle *arg2 = 0 ;
18471   Dali::BaseHandle *result = 0 ;
18472
18473   arg1 = (Dali::BaseHandle *)jarg1;
18474   arg2 = (Dali::BaseHandle *)jarg2;
18475   if (!arg2) {
18476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18477     return 0;
18478   }
18479   {
18480     try {
18481       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18482     } catch (std::out_of_range& e) {
18483       {
18484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18485       };
18486     } catch (std::exception& e) {
18487       {
18488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18489       };
18490     } catch (Dali::DaliException e) {
18491       {
18492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18493       };
18494     } catch (...) {
18495       {
18496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18497       };
18498     }
18499   }
18500
18501   jresult = (void *)result;
18502   return jresult;
18503 }
18504
18505
18506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18507   unsigned int jresult ;
18508   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18509   std::string *arg2 = 0 ;
18510   Dali::Property::Map *arg3 = 0 ;
18511   bool result;
18512
18513   arg1 = (Dali::BaseHandle *)jarg1;
18514   if (!jarg2) {
18515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18516     return 0;
18517   }
18518   std::string arg2_str(jarg2);
18519   arg2 = &arg2_str;
18520   arg3 = (Dali::Property::Map *)jarg3;
18521   if (!arg3) {
18522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18523     return 0;
18524   }
18525   {
18526     try {
18527       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18528     } catch (std::out_of_range& e) {
18529       {
18530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18531       };
18532     } catch (std::exception& e) {
18533       {
18534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18535       };
18536     } catch (Dali::DaliException e) {
18537       {
18538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18539       };
18540     } catch (...) {
18541       {
18542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18543       };
18544     }
18545   }
18546
18547   jresult = result;
18548
18549   //argout typemap for const std::string&
18550
18551   return jresult;
18552 }
18553
18554
18555 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18556   char * jresult ;
18557   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18558   std::string *result = 0 ;
18559
18560   arg1 = (Dali::BaseHandle *)jarg1;
18561   {
18562     try {
18563       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18564     } catch (std::out_of_range& e) {
18565       {
18566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18567       };
18568     } catch (std::exception& e) {
18569       {
18570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18571       };
18572     } catch (Dali::DaliException e) {
18573       {
18574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18575       };
18576     } catch (...) {
18577       {
18578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18579       };
18580     }
18581   }
18582
18583   jresult = SWIG_csharp_string_callback(result->c_str());
18584   return jresult;
18585 }
18586
18587
18588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18589   unsigned int jresult ;
18590   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18591   Dali::TypeInfo *arg2 = 0 ;
18592   bool result;
18593
18594   arg1 = (Dali::BaseHandle *)jarg1;
18595   arg2 = (Dali::TypeInfo *)jarg2;
18596   if (!arg2) {
18597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18598     return 0;
18599   }
18600   {
18601     try {
18602       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18603     } catch (std::out_of_range& e) {
18604       {
18605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18606       };
18607     } catch (std::exception& e) {
18608       {
18609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18610       };
18611     } catch (Dali::DaliException e) {
18612       {
18613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18614       };
18615     } catch (...) {
18616       {
18617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18618       };
18619     }
18620   }
18621
18622   jresult = result;
18623   return jresult;
18624 }
18625
18626
18627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18628   void * jresult ;
18629   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18630   Dali::BaseObject *result = 0 ;
18631
18632   arg1 = (Dali::BaseHandle *)jarg1;
18633   {
18634     try {
18635       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18636     } catch (std::out_of_range& e) {
18637       {
18638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18639       };
18640     } catch (std::exception& e) {
18641       {
18642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18643       };
18644     } catch (Dali::DaliException e) {
18645       {
18646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18647       };
18648     } catch (...) {
18649       {
18650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18651       };
18652     }
18653   }
18654
18655   jresult = (void *)result;
18656   return jresult;
18657 }
18658
18659
18660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18661   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18662
18663   arg1 = (Dali::BaseHandle *)jarg1;
18664   {
18665     try {
18666       (arg1)->Reset();
18667     } catch (std::out_of_range& e) {
18668       {
18669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18670       };
18671     } catch (std::exception& e) {
18672       {
18673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18674       };
18675     } catch (Dali::DaliException e) {
18676       {
18677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18678       };
18679     } catch (...) {
18680       {
18681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18682       };
18683     }
18684   }
18685
18686 }
18687
18688
18689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18690   unsigned int jresult ;
18691   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18692   Dali::BaseHandle *arg2 = 0 ;
18693   bool result;
18694
18695   arg1 = (Dali::BaseHandle *)jarg1;
18696   arg2 = (Dali::BaseHandle *)jarg2;
18697   if (!arg2) {
18698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18699     return 0;
18700   }
18701   {
18702     try {
18703       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18704     } catch (std::out_of_range& e) {
18705       {
18706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18707       };
18708     } catch (std::exception& e) {
18709       {
18710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18711       };
18712     } catch (Dali::DaliException e) {
18713       {
18714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18715       };
18716     } catch (...) {
18717       {
18718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18719       };
18720     }
18721   }
18722
18723   jresult = result;
18724   return jresult;
18725 }
18726
18727
18728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18729   unsigned int jresult ;
18730   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18731   Dali::BaseHandle *arg2 = 0 ;
18732   bool result;
18733
18734   arg1 = (Dali::BaseHandle *)jarg1;
18735   arg2 = (Dali::BaseHandle *)jarg2;
18736   if (!arg2) {
18737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18738     return 0;
18739   }
18740   {
18741     try {
18742       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18743     } catch (std::out_of_range& e) {
18744       {
18745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18746       };
18747     } catch (std::exception& e) {
18748       {
18749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18750       };
18751     } catch (Dali::DaliException e) {
18752       {
18753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18754       };
18755     } catch (...) {
18756       {
18757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18758       };
18759     }
18760   }
18761
18762   jresult = result;
18763   return jresult;
18764 }
18765
18766
18767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18768   void * jresult ;
18769   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18770   Dali::RefObject *result = 0 ;
18771
18772   arg1 = (Dali::BaseHandle *)jarg1;
18773   {
18774     try {
18775       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18776     } catch (std::out_of_range& e) {
18777       {
18778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18779       };
18780     } catch (std::exception& e) {
18781       {
18782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18783       };
18784     } catch (Dali::DaliException e) {
18785       {
18786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18787       };
18788     } catch (...) {
18789       {
18790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18791       };
18792     }
18793   }
18794
18795   jresult = (void *)result;
18796   return jresult;
18797 }
18798
18799
18800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18801   unsigned int jresult ;
18802   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18803   bool result;
18804
18805   arg1 = (Dali::BaseHandle *)jarg1;
18806   {
18807     try {
18808       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18809     } catch (std::out_of_range& e) {
18810       {
18811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18812       };
18813     } catch (std::exception& e) {
18814       {
18815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18816       };
18817     } catch (Dali::DaliException e) {
18818       {
18819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18820       };
18821     } catch (...) {
18822       {
18823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18824       };
18825     }
18826   }
18827
18828   jresult = result;
18829   return jresult;
18830 }
18831
18832
18833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18834   unsigned int jresult ;
18835   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18836   Dali::BaseHandle *arg2 = 0 ;
18837   bool result;
18838
18839   arg1 = (Dali::BaseHandle *)jarg1;
18840   arg2 = (Dali::BaseHandle *)jarg2;
18841   if (!arg2) {
18842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18843     return 0;
18844   }
18845   {
18846     try {
18847       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18848     } catch (std::out_of_range& e) {
18849       {
18850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18851       };
18852     } catch (std::exception& e) {
18853       {
18854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18855       };
18856     } catch (Dali::DaliException e) {
18857       {
18858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18859       };
18860     } catch (...) {
18861       {
18862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18863       };
18864     }
18865   }
18866
18867   jresult = result;
18868   return jresult;
18869 }
18870
18871
18872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18873   unsigned int jresult ;
18874   Dali::BaseHandle *arg1 = 0 ;
18875   Dali::BaseHandle *arg2 = 0 ;
18876   bool result;
18877
18878   arg1 = (Dali::BaseHandle *)jarg1;
18879   if (!arg1) {
18880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18881     return 0;
18882   }
18883   arg2 = (Dali::BaseHandle *)jarg2;
18884   if (!arg2) {
18885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18886     return 0;
18887   }
18888   {
18889     try {
18890       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18891     } catch (std::out_of_range& e) {
18892       {
18893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18894       };
18895     } catch (std::exception& e) {
18896       {
18897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18898       };
18899     } catch (Dali::DaliException e) {
18900       {
18901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18902       };
18903     } catch (...) {
18904       {
18905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18906       };
18907     }
18908   }
18909
18910   jresult = result;
18911   return jresult;
18912 }
18913
18914
18915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18916   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18917
18918   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18919   {
18920     try {
18921       delete arg1;
18922     } catch (std::out_of_range& e) {
18923       {
18924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18925       };
18926     } catch (std::exception& e) {
18927       {
18928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18929       };
18930     } catch (Dali::DaliException e) {
18931       {
18932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18933       };
18934     } catch (...) {
18935       {
18936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18937       };
18938     }
18939   }
18940
18941 }
18942
18943
18944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18945   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18946   SlotObserver *arg2 = (SlotObserver *) 0 ;
18947   CallbackBase *arg3 = (CallbackBase *) 0 ;
18948
18949   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18950   arg2 = (SlotObserver *)jarg2;
18951   arg3 = (CallbackBase *)jarg3;
18952   {
18953     try {
18954       (arg1)->SignalConnected(arg2,arg3);
18955     } catch (std::out_of_range& e) {
18956       {
18957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18958       };
18959     } catch (std::exception& e) {
18960       {
18961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18962       };
18963     } catch (Dali::DaliException e) {
18964       {
18965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18966       };
18967     } catch (...) {
18968       {
18969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18970       };
18971     }
18972   }
18973
18974 }
18975
18976
18977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18978   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18979
18980   arg1 = (Dali::SignalObserver *)jarg1;
18981   {
18982     try {
18983       delete arg1;
18984     } catch (std::out_of_range& e) {
18985       {
18986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18987       };
18988     } catch (std::exception& e) {
18989       {
18990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18991       };
18992     } catch (Dali::DaliException e) {
18993       {
18994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18995       };
18996     } catch (...) {
18997       {
18998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18999       };
19000     }
19001   }
19002
19003 }
19004
19005
19006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19007   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
19008   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19009   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19010
19011   arg1 = (Dali::SignalObserver *)jarg1;
19012   arg2 = (Dali::SlotObserver *)jarg2;
19013   arg3 = (Dali::CallbackBase *)jarg3;
19014   {
19015     try {
19016       (arg1)->SignalDisconnected(arg2,arg3);
19017     } catch (std::out_of_range& e) {
19018       {
19019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19020       };
19021     } catch (std::exception& e) {
19022       {
19023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19024       };
19025     } catch (Dali::DaliException e) {
19026       {
19027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19028       };
19029     } catch (...) {
19030       {
19031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19032       };
19033     }
19034   }
19035
19036 }
19037
19038
19039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19040   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19041
19042   arg1 = (Dali::SlotObserver *)jarg1;
19043   {
19044     try {
19045       delete arg1;
19046     } catch (std::out_of_range& e) {
19047       {
19048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19049       };
19050     } catch (std::exception& e) {
19051       {
19052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19053       };
19054     } catch (Dali::DaliException e) {
19055       {
19056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19057       };
19058     } catch (...) {
19059       {
19060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19061       };
19062     }
19063   }
19064
19065 }
19066
19067
19068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19069   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19070   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19071
19072   arg1 = (Dali::SlotObserver *)jarg1;
19073   arg2 = (Dali::CallbackBase *)jarg2;
19074   {
19075     try {
19076       (arg1)->SlotDisconnected(arg2);
19077     } catch (std::out_of_range& e) {
19078       {
19079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19080       };
19081     } catch (std::exception& e) {
19082       {
19083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19084       };
19085     } catch (Dali::DaliException e) {
19086       {
19087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19088       };
19089     } catch (...) {
19090       {
19091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19092       };
19093     }
19094   }
19095
19096 }
19097
19098
19099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19100   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19101
19102   arg1 = (Dali::ConnectionTracker *)jarg1;
19103   {
19104     try {
19105       delete arg1;
19106     } catch (std::out_of_range& e) {
19107       {
19108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19109       };
19110     } catch (std::exception& e) {
19111       {
19112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19113       };
19114     } catch (Dali::DaliException e) {
19115       {
19116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19117       };
19118     } catch (...) {
19119       {
19120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19121       };
19122     }
19123   }
19124
19125 }
19126
19127
19128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19129   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19130
19131   arg1 = (Dali::ConnectionTracker *)jarg1;
19132   {
19133     try {
19134       (arg1)->DisconnectAll();
19135     } catch (std::out_of_range& e) {
19136       {
19137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19138       };
19139     } catch (std::exception& e) {
19140       {
19141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19142       };
19143     } catch (Dali::DaliException e) {
19144       {
19145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19146       };
19147     } catch (...) {
19148       {
19149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19150       };
19151     }
19152   }
19153
19154 }
19155
19156
19157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19158   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19159   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19160   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19161
19162   arg1 = (Dali::ConnectionTracker *)jarg1;
19163   arg2 = (Dali::SlotObserver *)jarg2;
19164   arg3 = (Dali::CallbackBase *)jarg3;
19165   {
19166     try {
19167       (arg1)->SignalConnected(arg2,arg3);
19168     } catch (std::out_of_range& e) {
19169       {
19170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19171       };
19172     } catch (std::exception& e) {
19173       {
19174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19175       };
19176     } catch (Dali::DaliException e) {
19177       {
19178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19179       };
19180     } catch (...) {
19181       {
19182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19183       };
19184     }
19185   }
19186
19187 }
19188
19189
19190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19191   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19192   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19193   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19194
19195   arg1 = (Dali::ConnectionTracker *)jarg1;
19196   arg2 = (Dali::SlotObserver *)jarg2;
19197   arg3 = (Dali::CallbackBase *)jarg3;
19198   {
19199     try {
19200       (arg1)->SignalDisconnected(arg2,arg3);
19201     } catch (std::out_of_range& e) {
19202       {
19203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19204       };
19205     } catch (std::exception& e) {
19206       {
19207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19208       };
19209     } catch (Dali::DaliException e) {
19210       {
19211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19212       };
19213     } catch (...) {
19214       {
19215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19216       };
19217     }
19218   }
19219
19220 }
19221
19222
19223 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19224   unsigned long jresult ;
19225   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19226   std::size_t result;
19227
19228   arg1 = (Dali::ConnectionTracker *)jarg1;
19229   {
19230     try {
19231       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19232     } catch (std::out_of_range& e) {
19233       {
19234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19235       };
19236     } catch (std::exception& e) {
19237       {
19238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19239       };
19240     } catch (Dali::DaliException e) {
19241       {
19242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19243       };
19244     } catch (...) {
19245       {
19246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19247       };
19248     }
19249   }
19250
19251   jresult = (unsigned long)result;
19252   return jresult;
19253 }
19254
19255
19256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19257   void * jresult ;
19258   Dali::ObjectRegistry *result = 0 ;
19259
19260   {
19261     try {
19262       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19263     } catch (std::out_of_range& e) {
19264       {
19265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19266       };
19267     } catch (std::exception& e) {
19268       {
19269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19270       };
19271     } catch (Dali::DaliException e) {
19272       {
19273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19274       };
19275     } catch (...) {
19276       {
19277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19278       };
19279     }
19280   }
19281
19282   jresult = (void *)result;
19283   return jresult;
19284 }
19285
19286
19287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19288   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19289
19290   arg1 = (Dali::ObjectRegistry *)jarg1;
19291   {
19292     try {
19293       delete arg1;
19294     } catch (std::out_of_range& e) {
19295       {
19296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19297       };
19298     } catch (std::exception& e) {
19299       {
19300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19301       };
19302     } catch (Dali::DaliException e) {
19303       {
19304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19305       };
19306     } catch (...) {
19307       {
19308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19309       };
19310     }
19311   }
19312
19313 }
19314
19315
19316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19317   void * jresult ;
19318   Dali::ObjectRegistry *arg1 = 0 ;
19319   Dali::ObjectRegistry *result = 0 ;
19320
19321   arg1 = (Dali::ObjectRegistry *)jarg1;
19322   if (!arg1) {
19323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19324     return 0;
19325   }
19326   {
19327     try {
19328       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19329     } catch (std::out_of_range& e) {
19330       {
19331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19332       };
19333     } catch (std::exception& e) {
19334       {
19335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19336       };
19337     } catch (Dali::DaliException e) {
19338       {
19339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19340       };
19341     } catch (...) {
19342       {
19343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19344       };
19345     }
19346   }
19347
19348   jresult = (void *)result;
19349   return jresult;
19350 }
19351
19352
19353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19354   void * jresult ;
19355   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19356   Dali::ObjectRegistry *arg2 = 0 ;
19357   Dali::ObjectRegistry *result = 0 ;
19358
19359   arg1 = (Dali::ObjectRegistry *)jarg1;
19360   arg2 = (Dali::ObjectRegistry *)jarg2;
19361   if (!arg2) {
19362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19363     return 0;
19364   }
19365   {
19366     try {
19367       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19368     } catch (std::out_of_range& e) {
19369       {
19370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19371       };
19372     } catch (std::exception& e) {
19373       {
19374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19375       };
19376     } catch (Dali::DaliException e) {
19377       {
19378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19379       };
19380     } catch (...) {
19381       {
19382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19383       };
19384     }
19385   }
19386
19387   jresult = (void *)result;
19388   return jresult;
19389 }
19390
19391
19392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19393   void * jresult ;
19394   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19395   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19396
19397   arg1 = (Dali::ObjectRegistry *)jarg1;
19398   {
19399     try {
19400       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19401     } catch (std::out_of_range& e) {
19402       {
19403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19404       };
19405     } catch (std::exception& e) {
19406       {
19407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19408       };
19409     } catch (Dali::DaliException e) {
19410       {
19411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19412       };
19413     } catch (...) {
19414       {
19415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19416       };
19417     }
19418   }
19419
19420   jresult = (void *)result;
19421   return jresult;
19422 }
19423
19424
19425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19426   void * jresult ;
19427   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19428   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19429
19430   arg1 = (Dali::ObjectRegistry *)jarg1;
19431   {
19432     try {
19433       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19434     } catch (std::out_of_range& e) {
19435       {
19436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19437       };
19438     } catch (std::exception& e) {
19439       {
19440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19441       };
19442     } catch (Dali::DaliException e) {
19443       {
19444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19445       };
19446     } catch (...) {
19447       {
19448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19449       };
19450     }
19451   }
19452
19453   jresult = (void *)result;
19454   return jresult;
19455 }
19456
19457
19458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19459   void * jresult ;
19460   Dali::PropertyCondition *result = 0 ;
19461
19462   {
19463     try {
19464       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19465     } catch (std::out_of_range& e) {
19466       {
19467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19468       };
19469     } catch (std::exception& e) {
19470       {
19471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19472       };
19473     } catch (Dali::DaliException e) {
19474       {
19475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19476       };
19477     } catch (...) {
19478       {
19479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19480       };
19481     }
19482   }
19483
19484   jresult = (void *)result;
19485   return jresult;
19486 }
19487
19488
19489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19490   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19491
19492   arg1 = (Dali::PropertyCondition *)jarg1;
19493   {
19494     try {
19495       delete arg1;
19496     } catch (std::out_of_range& e) {
19497       {
19498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19499       };
19500     } catch (std::exception& e) {
19501       {
19502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19503       };
19504     } catch (Dali::DaliException e) {
19505       {
19506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19507       };
19508     } catch (...) {
19509       {
19510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19511       };
19512     }
19513   }
19514
19515 }
19516
19517
19518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19519   void * jresult ;
19520   Dali::PropertyCondition *arg1 = 0 ;
19521   Dali::PropertyCondition *result = 0 ;
19522
19523   arg1 = (Dali::PropertyCondition *)jarg1;
19524   if (!arg1) {
19525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19526     return 0;
19527   }
19528   {
19529     try {
19530       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19531     } catch (std::out_of_range& e) {
19532       {
19533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19534       };
19535     } catch (std::exception& e) {
19536       {
19537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19538       };
19539     } catch (Dali::DaliException e) {
19540       {
19541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19542       };
19543     } catch (...) {
19544       {
19545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19546       };
19547     }
19548   }
19549
19550   jresult = (void *)result;
19551   return jresult;
19552 }
19553
19554
19555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19556   void * jresult ;
19557   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19558   Dali::PropertyCondition *arg2 = 0 ;
19559   Dali::PropertyCondition *result = 0 ;
19560
19561   arg1 = (Dali::PropertyCondition *)jarg1;
19562   arg2 = (Dali::PropertyCondition *)jarg2;
19563   if (!arg2) {
19564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19565     return 0;
19566   }
19567   {
19568     try {
19569       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19570     } catch (std::out_of_range& e) {
19571       {
19572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19573       };
19574     } catch (std::exception& e) {
19575       {
19576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19577       };
19578     } catch (Dali::DaliException e) {
19579       {
19580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19581       };
19582     } catch (...) {
19583       {
19584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19585       };
19586     }
19587   }
19588
19589   jresult = (void *)result;
19590   return jresult;
19591 }
19592
19593
19594 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19595   unsigned long jresult ;
19596   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19597   std::size_t result;
19598
19599   arg1 = (Dali::PropertyCondition *)jarg1;
19600   {
19601     try {
19602       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19603     } catch (std::out_of_range& e) {
19604       {
19605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19606       };
19607     } catch (std::exception& e) {
19608       {
19609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19610       };
19611     } catch (...) {
19612       {
19613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19614       };
19615     }
19616   }
19617   jresult = (unsigned long)result;
19618   return jresult;
19619 }
19620
19621
19622 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19623   float jresult ;
19624   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19625   std::size_t arg2 ;
19626   float result;
19627
19628   arg1 = (Dali::PropertyCondition *)jarg1;
19629   arg2 = (std::size_t)jarg2;
19630   {
19631     try {
19632       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19633     } catch (std::out_of_range& e) {
19634       {
19635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19636       };
19637     } catch (std::exception& e) {
19638       {
19639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19640       };
19641     } catch (...) {
19642       {
19643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19644       };
19645     }
19646   }
19647   jresult = result;
19648   return jresult;
19649 }
19650
19651
19652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19653   void * jresult ;
19654   float arg1 ;
19655   Dali::PropertyCondition result;
19656
19657   arg1 = (float)jarg1;
19658   {
19659     try {
19660       result = Dali::LessThanCondition(arg1);
19661     } catch (std::out_of_range& e) {
19662       {
19663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19664       };
19665     } catch (std::exception& e) {
19666       {
19667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19668       };
19669     } catch (Dali::DaliException e) {
19670       {
19671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19672       };
19673     } catch (...) {
19674       {
19675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19676       };
19677     }
19678   }
19679
19680   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19681   return jresult;
19682 }
19683
19684
19685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19686   void * jresult ;
19687   float arg1 ;
19688   Dali::PropertyCondition result;
19689
19690   arg1 = (float)jarg1;
19691   {
19692     try {
19693       result = Dali::GreaterThanCondition(arg1);
19694     } catch (std::out_of_range& e) {
19695       {
19696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19697       };
19698     } catch (std::exception& e) {
19699       {
19700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19701       };
19702     } catch (Dali::DaliException e) {
19703       {
19704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19705       };
19706     } catch (...) {
19707       {
19708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19709       };
19710     }
19711   }
19712
19713   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19714   return jresult;
19715 }
19716
19717
19718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19719   void * jresult ;
19720   float arg1 ;
19721   float arg2 ;
19722   Dali::PropertyCondition result;
19723
19724   arg1 = (float)jarg1;
19725   arg2 = (float)jarg2;
19726   {
19727     try {
19728       result = Dali::InsideCondition(arg1,arg2);
19729     } catch (std::out_of_range& e) {
19730       {
19731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19732       };
19733     } catch (std::exception& e) {
19734       {
19735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19736       };
19737     } catch (Dali::DaliException e) {
19738       {
19739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19740       };
19741     } catch (...) {
19742       {
19743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19744       };
19745     }
19746   }
19747
19748   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19749   return jresult;
19750 }
19751
19752
19753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19754   void * jresult ;
19755   float arg1 ;
19756   float arg2 ;
19757   Dali::PropertyCondition result;
19758
19759   arg1 = (float)jarg1;
19760   arg2 = (float)jarg2;
19761   {
19762     try {
19763       result = Dali::OutsideCondition(arg1,arg2);
19764     } catch (std::out_of_range& e) {
19765       {
19766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19767       };
19768     } catch (std::exception& e) {
19769       {
19770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19771       };
19772     } catch (Dali::DaliException e) {
19773       {
19774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19775       };
19776     } catch (...) {
19777       {
19778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19779       };
19780     }
19781   }
19782
19783   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19784   return jresult;
19785 }
19786
19787
19788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19789   void * jresult ;
19790   float arg1 ;
19791   float arg2 ;
19792   Dali::PropertyCondition result;
19793
19794   arg1 = (float)jarg1;
19795   arg2 = (float)jarg2;
19796   {
19797     try {
19798       result = Dali::StepCondition(arg1,arg2);
19799     } catch (std::out_of_range& e) {
19800       {
19801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19802       };
19803     } catch (std::exception& e) {
19804       {
19805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19806       };
19807     } catch (Dali::DaliException e) {
19808       {
19809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19810       };
19811     } catch (...) {
19812       {
19813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19814       };
19815     }
19816   }
19817
19818   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19819   return jresult;
19820 }
19821
19822
19823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19824   void * jresult ;
19825   float arg1 ;
19826   Dali::PropertyCondition result;
19827
19828   arg1 = (float)jarg1;
19829   {
19830     try {
19831       result = Dali::StepCondition(arg1);
19832     } catch (std::out_of_range& e) {
19833       {
19834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19835       };
19836     } catch (std::exception& e) {
19837       {
19838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19839       };
19840     } catch (Dali::DaliException e) {
19841       {
19842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19843       };
19844     } catch (...) {
19845       {
19846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19847       };
19848     }
19849   }
19850
19851   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19852   return jresult;
19853 }
19854
19855
19856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19857   void * jresult ;
19858   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19859   Dali::PropertyCondition result;
19860
19861   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19862   if (!arg1) {
19863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19864     return 0;
19865   }
19866   {
19867     try {
19868       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19869     } catch (std::out_of_range& e) {
19870       {
19871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19872       };
19873     } catch (std::exception& e) {
19874       {
19875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19876       };
19877     } catch (Dali::DaliException e) {
19878       {
19879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19880       };
19881     } catch (...) {
19882       {
19883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19884       };
19885     }
19886   }
19887
19888   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19889   return jresult;
19890 }
19891
19892
19893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19894   void * jresult ;
19895   Dali::PropertyNotification *result = 0 ;
19896
19897   {
19898     try {
19899       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19900     } catch (std::out_of_range& e) {
19901       {
19902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19903       };
19904     } catch (std::exception& e) {
19905       {
19906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19907       };
19908     } catch (Dali::DaliException e) {
19909       {
19910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19911       };
19912     } catch (...) {
19913       {
19914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19915       };
19916     }
19917   }
19918
19919   jresult = (void *)result;
19920   return jresult;
19921 }
19922
19923
19924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19925   void * jresult ;
19926   Dali::BaseHandle arg1 ;
19927   Dali::BaseHandle *argp1 ;
19928   Dali::PropertyNotification result;
19929
19930   argp1 = (Dali::BaseHandle *)jarg1;
19931   if (!argp1) {
19932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19933     return 0;
19934   }
19935   arg1 = *argp1;
19936   {
19937     try {
19938       result = Dali::PropertyNotification::DownCast(arg1);
19939     } catch (std::out_of_range& e) {
19940       {
19941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19942       };
19943     } catch (std::exception& e) {
19944       {
19945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19946       };
19947     } catch (Dali::DaliException e) {
19948       {
19949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19950       };
19951     } catch (...) {
19952       {
19953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19954       };
19955     }
19956   }
19957
19958   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19959   return jresult;
19960 }
19961
19962
19963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19964   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19965
19966   arg1 = (Dali::PropertyNotification *)jarg1;
19967   {
19968     try {
19969       delete arg1;
19970     } catch (std::out_of_range& e) {
19971       {
19972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19973       };
19974     } catch (std::exception& e) {
19975       {
19976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19977       };
19978     } catch (Dali::DaliException e) {
19979       {
19980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19981       };
19982     } catch (...) {
19983       {
19984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19985       };
19986     }
19987   }
19988
19989 }
19990
19991
19992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19993   void * jresult ;
19994   Dali::PropertyNotification *arg1 = 0 ;
19995   Dali::PropertyNotification *result = 0 ;
19996
19997   arg1 = (Dali::PropertyNotification *)jarg1;
19998   if (!arg1) {
19999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20000     return 0;
20001   }
20002   {
20003     try {
20004       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
20005     } catch (std::out_of_range& e) {
20006       {
20007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20008       };
20009     } catch (std::exception& e) {
20010       {
20011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20012       };
20013     } catch (Dali::DaliException e) {
20014       {
20015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20016       };
20017     } catch (...) {
20018       {
20019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20020       };
20021     }
20022   }
20023
20024   jresult = (void *)result;
20025   return jresult;
20026 }
20027
20028
20029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
20030   void * jresult ;
20031   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20032   Dali::PropertyNotification *arg2 = 0 ;
20033   Dali::PropertyNotification *result = 0 ;
20034
20035   arg1 = (Dali::PropertyNotification *)jarg1;
20036   arg2 = (Dali::PropertyNotification *)jarg2;
20037   if (!arg2) {
20038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20039     return 0;
20040   }
20041   {
20042     try {
20043       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20044     } catch (std::out_of_range& e) {
20045       {
20046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20047       };
20048     } catch (std::exception& e) {
20049       {
20050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20051       };
20052     } catch (Dali::DaliException e) {
20053       {
20054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20055       };
20056     } catch (...) {
20057       {
20058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20059       };
20060     }
20061   }
20062
20063   jresult = (void *)result;
20064   return jresult;
20065 }
20066
20067
20068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20069   void * jresult ;
20070   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20071   Dali::PropertyCondition result;
20072
20073   arg1 = (Dali::PropertyNotification *)jarg1;
20074   {
20075     try {
20076       result = (arg1)->GetCondition();
20077     } catch (std::out_of_range& e) {
20078       {
20079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20080       };
20081     } catch (std::exception& e) {
20082       {
20083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20084       };
20085     } catch (Dali::DaliException e) {
20086       {
20087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20088       };
20089     } catch (...) {
20090       {
20091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20092       };
20093     }
20094   }
20095
20096   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20097   return jresult;
20098 }
20099
20100
20101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20102   void * jresult ;
20103   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20104   Dali::Handle result;
20105
20106   arg1 = (Dali::PropertyNotification *)jarg1;
20107   {
20108     try {
20109       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20110     } catch (std::out_of_range& e) {
20111       {
20112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20113       };
20114     } catch (std::exception& e) {
20115       {
20116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20117       };
20118     } catch (Dali::DaliException e) {
20119       {
20120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20121       };
20122     } catch (...) {
20123       {
20124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20125       };
20126     }
20127   }
20128
20129   jresult = new Dali::Handle((const Dali::Handle &)result);
20130   return jresult;
20131 }
20132
20133
20134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20135   int jresult ;
20136   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20137   Dali::Property::Index result;
20138
20139   arg1 = (Dali::PropertyNotification *)jarg1;
20140   {
20141     try {
20142       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20143     } catch (std::out_of_range& e) {
20144       {
20145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20146       };
20147     } catch (std::exception& e) {
20148       {
20149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20150       };
20151     } catch (Dali::DaliException e) {
20152       {
20153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20154       };
20155     } catch (...) {
20156       {
20157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20158       };
20159     }
20160   }
20161
20162   jresult = result;
20163   return jresult;
20164 }
20165
20166
20167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20168   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20169   Dali::PropertyNotification::NotifyMode arg2 ;
20170
20171   arg1 = (Dali::PropertyNotification *)jarg1;
20172   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20173   {
20174     try {
20175       (arg1)->SetNotifyMode(arg2);
20176     } catch (std::out_of_range& e) {
20177       {
20178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20179       };
20180     } catch (std::exception& e) {
20181       {
20182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20183       };
20184     } catch (Dali::DaliException e) {
20185       {
20186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20187       };
20188     } catch (...) {
20189       {
20190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20191       };
20192     }
20193   }
20194
20195 }
20196
20197
20198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20199   int jresult ;
20200   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20201   Dali::PropertyNotification::NotifyMode result;
20202
20203   arg1 = (Dali::PropertyNotification *)jarg1;
20204   {
20205     try {
20206       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20207     } catch (std::out_of_range& e) {
20208       {
20209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20210       };
20211     } catch (std::exception& e) {
20212       {
20213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20214       };
20215     } catch (Dali::DaliException e) {
20216       {
20217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20218       };
20219     } catch (...) {
20220       {
20221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20222       };
20223     }
20224   }
20225
20226   jresult = (int)result;
20227   return jresult;
20228 }
20229
20230
20231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20232   unsigned int jresult ;
20233   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20234   bool result;
20235
20236   arg1 = (Dali::PropertyNotification *)jarg1;
20237   {
20238     try {
20239       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20240     } catch (std::out_of_range& e) {
20241       {
20242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20243       };
20244     } catch (std::exception& e) {
20245       {
20246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20247       };
20248     } catch (Dali::DaliException e) {
20249       {
20250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20251       };
20252     } catch (...) {
20253       {
20254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20255       };
20256     }
20257   }
20258
20259   jresult = result;
20260   return jresult;
20261 }
20262
20263
20264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20265   void * jresult ;
20266   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20267   Dali::PropertyNotifySignalType *result = 0 ;
20268
20269   arg1 = (Dali::PropertyNotification *)jarg1;
20270   {
20271     try {
20272       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20273     } catch (std::out_of_range& e) {
20274       {
20275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20276       };
20277     } catch (std::exception& e) {
20278       {
20279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20280       };
20281     } catch (Dali::DaliException e) {
20282       {
20283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20284       };
20285     } catch (...) {
20286       {
20287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20288       };
20289     }
20290   }
20291
20292   jresult = (void *)result;
20293   return jresult;
20294 }
20295
20296
20297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20298   void * jresult ;
20299   Dali::Handle *result = 0 ;
20300
20301   {
20302     try {
20303       result = (Dali::Handle *)new Dali::Handle();
20304     } catch (std::out_of_range& e) {
20305       {
20306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20307       };
20308     } catch (std::exception& e) {
20309       {
20310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20311       };
20312     } catch (Dali::DaliException e) {
20313       {
20314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20315       };
20316     } catch (...) {
20317       {
20318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20319       };
20320     }
20321   }
20322
20323   jresult = (void *)result;
20324   return jresult;
20325 }
20326
20327
20328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20329   void * jresult ;
20330   Dali::Handle result;
20331
20332   {
20333     try {
20334       result = Dali::Handle::New();
20335     } catch (std::out_of_range& e) {
20336       {
20337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20338       };
20339     } catch (std::exception& e) {
20340       {
20341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20342       };
20343     } catch (Dali::DaliException e) {
20344       {
20345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20346       };
20347     } catch (...) {
20348       {
20349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20350       };
20351     }
20352   }
20353
20354   jresult = new Dali::Handle((const Dali::Handle &)result);
20355   return jresult;
20356 }
20357
20358
20359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20360   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20361
20362   arg1 = (Dali::Handle *)jarg1;
20363   {
20364     try {
20365       delete arg1;
20366     } catch (std::out_of_range& e) {
20367       {
20368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20369       };
20370     } catch (std::exception& e) {
20371       {
20372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20373       };
20374     } catch (Dali::DaliException e) {
20375       {
20376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20377       };
20378     } catch (...) {
20379       {
20380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20381       };
20382     }
20383   }
20384
20385 }
20386
20387
20388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20389   void * jresult ;
20390   Dali::Handle *arg1 = 0 ;
20391   Dali::Handle *result = 0 ;
20392
20393   arg1 = (Dali::Handle *)jarg1;
20394   if (!arg1) {
20395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20396     return 0;
20397   }
20398   {
20399     try {
20400       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20401     } catch (std::out_of_range& e) {
20402       {
20403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20404       };
20405     } catch (std::exception& e) {
20406       {
20407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20408       };
20409     } catch (Dali::DaliException e) {
20410       {
20411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20412       };
20413     } catch (...) {
20414       {
20415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20416       };
20417     }
20418   }
20419
20420   jresult = (void *)result;
20421   return jresult;
20422 }
20423
20424
20425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20426   void * jresult ;
20427   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20428   Dali::Handle *arg2 = 0 ;
20429   Dali::Handle *result = 0 ;
20430
20431   arg1 = (Dali::Handle *)jarg1;
20432   arg2 = (Dali::Handle *)jarg2;
20433   if (!arg2) {
20434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20435     return 0;
20436   }
20437   {
20438     try {
20439       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20440     } catch (std::out_of_range& e) {
20441       {
20442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20443       };
20444     } catch (std::exception& e) {
20445       {
20446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20447       };
20448     } catch (Dali::DaliException e) {
20449       {
20450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20451       };
20452     } catch (...) {
20453       {
20454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20455       };
20456     }
20457   }
20458
20459   jresult = (void *)result;
20460   return jresult;
20461 }
20462
20463
20464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20465   void * jresult ;
20466   Dali::BaseHandle arg1 ;
20467   Dali::BaseHandle *argp1 ;
20468   Dali::Handle result;
20469
20470   argp1 = (Dali::BaseHandle *)jarg1;
20471   if (!argp1) {
20472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20473     return 0;
20474   }
20475   arg1 = *argp1;
20476   {
20477     try {
20478       result = Dali::Handle::DownCast(arg1);
20479     } catch (std::out_of_range& e) {
20480       {
20481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20482       };
20483     } catch (std::exception& e) {
20484       {
20485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20486       };
20487     } catch (Dali::DaliException e) {
20488       {
20489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20490       };
20491     } catch (...) {
20492       {
20493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20494       };
20495     }
20496   }
20497
20498   jresult = new Dali::Handle((const Dali::Handle &)result);
20499   return jresult;
20500 }
20501
20502
20503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20504   unsigned int jresult ;
20505   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20506   Dali::Handle::Capability arg2 ;
20507   bool result;
20508
20509   arg1 = (Dali::Handle *)jarg1;
20510   arg2 = (Dali::Handle::Capability)jarg2;
20511   {
20512     try {
20513       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20514     } catch (std::out_of_range& e) {
20515       {
20516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20517       };
20518     } catch (std::exception& e) {
20519       {
20520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20521       };
20522     } catch (Dali::DaliException e) {
20523       {
20524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20525       };
20526     } catch (...) {
20527       {
20528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20529       };
20530     }
20531   }
20532
20533   jresult = result;
20534   return jresult;
20535 }
20536
20537
20538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20539   unsigned int jresult ;
20540   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20541   unsigned int result;
20542
20543   arg1 = (Dali::Handle *)jarg1;
20544   {
20545     try {
20546       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20547     } catch (std::out_of_range& e) {
20548       {
20549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20550       };
20551     } catch (std::exception& e) {
20552       {
20553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20554       };
20555     } catch (Dali::DaliException e) {
20556       {
20557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20558       };
20559     } catch (...) {
20560       {
20561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20562       };
20563     }
20564   }
20565
20566   jresult = result;
20567   return jresult;
20568 }
20569
20570
20571 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20572   char * jresult ;
20573   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20574   Dali::Property::Index arg2 ;
20575   std::string result;
20576
20577   arg1 = (Dali::Handle *)jarg1;
20578   arg2 = (Dali::Property::Index)jarg2;
20579   {
20580     try {
20581       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20582     } catch (std::out_of_range& e) {
20583       {
20584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20585       };
20586     } catch (std::exception& e) {
20587       {
20588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20589       };
20590     } catch (Dali::DaliException e) {
20591       {
20592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20593       };
20594     } catch (...) {
20595       {
20596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20597       };
20598     }
20599   }
20600
20601   jresult = SWIG_csharp_string_callback((&result)->c_str());
20602   return jresult;
20603 }
20604
20605
20606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20607   int jresult ;
20608   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20609   std::string *arg2 = 0 ;
20610   Dali::Property::Index result;
20611
20612   arg1 = (Dali::Handle *)jarg1;
20613   if (!jarg2) {
20614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20615     return 0;
20616   }
20617   std::string arg2_str(jarg2);
20618   arg2 = &arg2_str;
20619   {
20620     try {
20621       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20622     } catch (std::out_of_range& e) {
20623       {
20624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20625       };
20626     } catch (std::exception& e) {
20627       {
20628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20629       };
20630     } catch (Dali::DaliException e) {
20631       {
20632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20633       };
20634     } catch (...) {
20635       {
20636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20637       };
20638     }
20639   }
20640
20641   jresult = result;
20642
20643   //argout typemap for const std::string&
20644
20645   return jresult;
20646 }
20647
20648
20649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20650   unsigned int jresult ;
20651   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20652   Dali::Property::Index arg2 ;
20653   bool result;
20654
20655   arg1 = (Dali::Handle *)jarg1;
20656   arg2 = (Dali::Property::Index)jarg2;
20657   {
20658     try {
20659       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20660     } catch (std::out_of_range& e) {
20661       {
20662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20663       };
20664     } catch (std::exception& e) {
20665       {
20666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20667       };
20668     } catch (Dali::DaliException e) {
20669       {
20670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20671       };
20672     } catch (...) {
20673       {
20674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20675       };
20676     }
20677   }
20678
20679   jresult = result;
20680   return jresult;
20681 }
20682
20683
20684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20685   unsigned int jresult ;
20686   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20687   Dali::Property::Index arg2 ;
20688   bool result;
20689
20690   arg1 = (Dali::Handle *)jarg1;
20691   arg2 = (Dali::Property::Index)jarg2;
20692   {
20693     try {
20694       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20695     } catch (std::out_of_range& e) {
20696       {
20697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20698       };
20699     } catch (std::exception& e) {
20700       {
20701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20702       };
20703     } catch (Dali::DaliException e) {
20704       {
20705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20706       };
20707     } catch (...) {
20708       {
20709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20710       };
20711     }
20712   }
20713
20714   jresult = result;
20715   return jresult;
20716 }
20717
20718
20719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20720   unsigned int jresult ;
20721   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20722   Dali::Property::Index arg2 ;
20723   bool result;
20724
20725   arg1 = (Dali::Handle *)jarg1;
20726   arg2 = (Dali::Property::Index)jarg2;
20727   {
20728     try {
20729       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20730     } catch (std::out_of_range& e) {
20731       {
20732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20733       };
20734     } catch (std::exception& e) {
20735       {
20736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20737       };
20738     } catch (Dali::DaliException e) {
20739       {
20740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20741       };
20742     } catch (...) {
20743       {
20744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20745       };
20746     }
20747   }
20748
20749   jresult = result;
20750   return jresult;
20751 }
20752
20753
20754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20755   int jresult ;
20756   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20757   Dali::Property::Index arg2 ;
20758   Dali::Property::Type result;
20759
20760   arg1 = (Dali::Handle *)jarg1;
20761   arg2 = (Dali::Property::Index)jarg2;
20762   {
20763     try {
20764       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20765     } catch (std::out_of_range& e) {
20766       {
20767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20768       };
20769     } catch (std::exception& e) {
20770       {
20771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20772       };
20773     } catch (Dali::DaliException e) {
20774       {
20775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20776       };
20777     } catch (...) {
20778       {
20779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20780       };
20781     }
20782   }
20783
20784   jresult = (int)result;
20785   return jresult;
20786 }
20787
20788
20789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20790   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20791   Dali::Property::Index arg2 ;
20792   Dali::Property::Value *arg3 = 0 ;
20793
20794   arg1 = (Dali::Handle *)jarg1;
20795   arg2 = (Dali::Property::Index)jarg2;
20796   arg3 = (Dali::Property::Value *)jarg3;
20797   if (!arg3) {
20798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20799     return ;
20800   }
20801   {
20802     try {
20803       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20804     } catch (std::out_of_range& e) {
20805       {
20806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20807       };
20808     } catch (std::exception& e) {
20809       {
20810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20811       };
20812     } catch (Dali::DaliException e) {
20813       {
20814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20815       };
20816     } catch (...) {
20817       {
20818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20819       };
20820     }
20821   }
20822
20823 }
20824
20825
20826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20827   int jresult ;
20828   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20829   std::string *arg2 = 0 ;
20830   Dali::Property::Value *arg3 = 0 ;
20831   Dali::Property::Index result;
20832
20833   arg1 = (Dali::Handle *)jarg1;
20834   if (!jarg2) {
20835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20836     return 0;
20837   }
20838   std::string arg2_str(jarg2);
20839   arg2 = &arg2_str;
20840   arg3 = (Dali::Property::Value *)jarg3;
20841   if (!arg3) {
20842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20843     return 0;
20844   }
20845   {
20846     try {
20847       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20848     } catch (std::out_of_range& e) {
20849       {
20850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20851       };
20852     } catch (std::exception& e) {
20853       {
20854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20855       };
20856     } catch (Dali::DaliException e) {
20857       {
20858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20859       };
20860     } catch (...) {
20861       {
20862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20863       };
20864     }
20865   }
20866
20867   jresult = result;
20868
20869   //argout typemap for const std::string&
20870
20871   return jresult;
20872 }
20873
20874
20875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20876   int jresult ;
20877   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20878   std::string *arg2 = 0 ;
20879   Dali::Property::Value *arg3 = 0 ;
20880   Dali::Property::AccessMode arg4 ;
20881   Dali::Property::Index result;
20882
20883   arg1 = (Dali::Handle *)jarg1;
20884   if (!jarg2) {
20885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20886     return 0;
20887   }
20888   std::string arg2_str(jarg2);
20889   arg2 = &arg2_str;
20890   arg3 = (Dali::Property::Value *)jarg3;
20891   if (!arg3) {
20892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20893     return 0;
20894   }
20895   arg4 = (Dali::Property::AccessMode)jarg4;
20896   {
20897     try {
20898       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20899     } catch (std::out_of_range& e) {
20900       {
20901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20902       };
20903     } catch (std::exception& e) {
20904       {
20905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20906       };
20907     } catch (Dali::DaliException e) {
20908       {
20909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20910       };
20911     } catch (...) {
20912       {
20913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20914       };
20915     }
20916   }
20917
20918   jresult = result;
20919
20920   //argout typemap for const std::string&
20921
20922   return jresult;
20923 }
20924
20925
20926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20927   void * jresult ;
20928   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20929   Dali::Property::Index arg2 ;
20930   Dali::Property::Value result;
20931
20932   arg1 = (Dali::Handle *)jarg1;
20933   arg2 = (Dali::Property::Index)jarg2;
20934   {
20935     try {
20936       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20937     } catch (std::out_of_range& e) {
20938       {
20939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20940       };
20941     } catch (std::exception& e) {
20942       {
20943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20944       };
20945     } catch (Dali::DaliException e) {
20946       {
20947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20948       };
20949     } catch (...) {
20950       {
20951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20952       };
20953     }
20954   }
20955
20956   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20957   return jresult;
20958 }
20959
20960
20961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20962   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20963   Dali::Property::IndexContainer *arg2 = 0 ;
20964
20965   arg1 = (Dali::Handle *)jarg1;
20966   arg2 = (Dali::Property::IndexContainer *)jarg2;
20967   if (!arg2) {
20968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20969     return ;
20970   }
20971   {
20972     try {
20973       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20974     } catch (std::out_of_range& e) {
20975       {
20976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20977       };
20978     } catch (std::exception& e) {
20979       {
20980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20981       };
20982     } catch (Dali::DaliException e) {
20983       {
20984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20985       };
20986     } catch (...) {
20987       {
20988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20989       };
20990     }
20991   }
20992
20993 }
20994
20995
20996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20997   void * jresult ;
20998   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20999   Dali::Property::Index arg2 ;
21000   Dali::PropertyCondition *arg3 = 0 ;
21001   Dali::PropertyNotification result;
21002
21003   arg1 = (Dali::Handle *)jarg1;
21004   arg2 = (Dali::Property::Index)jarg2;
21005   arg3 = (Dali::PropertyCondition *)jarg3;
21006   if (!arg3) {
21007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21008     return 0;
21009   }
21010   {
21011     try {
21012       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
21013     } catch (std::out_of_range& e) {
21014       {
21015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21016       };
21017     } catch (std::exception& e) {
21018       {
21019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21020       };
21021     } catch (Dali::DaliException e) {
21022       {
21023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21024       };
21025     } catch (...) {
21026       {
21027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21028       };
21029     }
21030   }
21031
21032   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21033   return jresult;
21034 }
21035
21036
21037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21038   void * jresult ;
21039   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21040   Dali::Property::Index arg2 ;
21041   int arg3 ;
21042   Dali::PropertyCondition *arg4 = 0 ;
21043   Dali::PropertyNotification result;
21044
21045   arg1 = (Dali::Handle *)jarg1;
21046   arg2 = (Dali::Property::Index)jarg2;
21047   arg3 = (int)jarg3;
21048   arg4 = (Dali::PropertyCondition *)jarg4;
21049   if (!arg4) {
21050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21051     return 0;
21052   }
21053   {
21054     try {
21055       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21056     } catch (std::out_of_range& e) {
21057       {
21058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21059       };
21060     } catch (std::exception& e) {
21061       {
21062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21063       };
21064     } catch (Dali::DaliException e) {
21065       {
21066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21067       };
21068     } catch (...) {
21069       {
21070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21071       };
21072     }
21073   }
21074
21075   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21076   return jresult;
21077 }
21078
21079
21080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21081   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21082   Dali::PropertyNotification arg2 ;
21083   Dali::PropertyNotification *argp2 ;
21084
21085   arg1 = (Dali::Handle *)jarg1;
21086   argp2 = (Dali::PropertyNotification *)jarg2;
21087   if (!argp2) {
21088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21089     return ;
21090   }
21091   arg2 = *argp2;
21092   {
21093     try {
21094       (arg1)->RemovePropertyNotification(arg2);
21095     } catch (std::out_of_range& e) {
21096       {
21097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21098       };
21099     } catch (std::exception& e) {
21100       {
21101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21102       };
21103     } catch (Dali::DaliException e) {
21104       {
21105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21106       };
21107     } catch (...) {
21108       {
21109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21110       };
21111     }
21112   }
21113
21114 }
21115
21116
21117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21118   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21119
21120   arg1 = (Dali::Handle *)jarg1;
21121   {
21122     try {
21123       (arg1)->RemovePropertyNotifications();
21124     } catch (std::out_of_range& e) {
21125       {
21126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21127       };
21128     } catch (std::exception& e) {
21129       {
21130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21131       };
21132     } catch (Dali::DaliException e) {
21133       {
21134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21135       };
21136     } catch (...) {
21137       {
21138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21139       };
21140     }
21141   }
21142
21143 }
21144
21145
21146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21147   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21148
21149   arg1 = (Dali::Handle *)jarg1;
21150   {
21151     try {
21152       (arg1)->RemoveConstraints();
21153     } catch (std::out_of_range& e) {
21154       {
21155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21156       };
21157     } catch (std::exception& e) {
21158       {
21159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21160       };
21161     } catch (Dali::DaliException e) {
21162       {
21163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21164       };
21165     } catch (...) {
21166       {
21167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21168       };
21169     }
21170   }
21171
21172 }
21173
21174
21175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21176   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21177   unsigned int arg2 ;
21178
21179   arg1 = (Dali::Handle *)jarg1;
21180   arg2 = (unsigned int)jarg2;
21181   {
21182     try {
21183       (arg1)->RemoveConstraints(arg2);
21184     } catch (std::out_of_range& e) {
21185       {
21186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21187       };
21188     } catch (std::exception& e) {
21189       {
21190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21191       };
21192     } catch (Dali::DaliException e) {
21193       {
21194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21195       };
21196     } catch (...) {
21197       {
21198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21199       };
21200     }
21201   }
21202
21203 }
21204
21205
21206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21207   int jresult ;
21208   Dali::Property::Index result;
21209
21210   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21211   jresult = result;
21212   return jresult;
21213 }
21214
21215
21216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21217   void * jresult ;
21218   Dali::Handle result;
21219
21220   {
21221     try {
21222       result = Dali::WeightObject::New();
21223     } catch (std::out_of_range& e) {
21224       {
21225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21226       };
21227     } catch (std::exception& e) {
21228       {
21229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21230       };
21231     } catch (Dali::DaliException e) {
21232       {
21233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21234       };
21235     } catch (...) {
21236       {
21237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21238       };
21239     }
21240   }
21241
21242   jresult = new Dali::Handle((const Dali::Handle &)result);
21243   return jresult;
21244 }
21245
21246
21247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21248   void * jresult ;
21249   Dali::TypeInfo *result = 0 ;
21250
21251   {
21252     try {
21253       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21254     } catch (std::out_of_range& e) {
21255       {
21256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21257       };
21258     } catch (std::exception& e) {
21259       {
21260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21261       };
21262     } catch (Dali::DaliException e) {
21263       {
21264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21265       };
21266     } catch (...) {
21267       {
21268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21269       };
21270     }
21271   }
21272
21273   jresult = (void *)result;
21274   return jresult;
21275 }
21276
21277
21278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21279   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21280
21281   arg1 = (Dali::TypeInfo *)jarg1;
21282   {
21283     try {
21284       delete arg1;
21285     } catch (std::out_of_range& e) {
21286       {
21287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21288       };
21289     } catch (std::exception& e) {
21290       {
21291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21292       };
21293     } catch (Dali::DaliException e) {
21294       {
21295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21296       };
21297     } catch (...) {
21298       {
21299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21300       };
21301     }
21302   }
21303
21304 }
21305
21306
21307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21308   void * jresult ;
21309   Dali::TypeInfo *arg1 = 0 ;
21310   Dali::TypeInfo *result = 0 ;
21311
21312   arg1 = (Dali::TypeInfo *)jarg1;
21313   if (!arg1) {
21314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21315     return 0;
21316   }
21317   {
21318     try {
21319       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21320     } catch (std::out_of_range& e) {
21321       {
21322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21323       };
21324     } catch (std::exception& e) {
21325       {
21326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21327       };
21328     } catch (Dali::DaliException e) {
21329       {
21330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21331       };
21332     } catch (...) {
21333       {
21334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21335       };
21336     }
21337   }
21338
21339   jresult = (void *)result;
21340   return jresult;
21341 }
21342
21343
21344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21345   void * jresult ;
21346   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21347   Dali::TypeInfo *arg2 = 0 ;
21348   Dali::TypeInfo *result = 0 ;
21349
21350   arg1 = (Dali::TypeInfo *)jarg1;
21351   arg2 = (Dali::TypeInfo *)jarg2;
21352   if (!arg2) {
21353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21354     return 0;
21355   }
21356   {
21357     try {
21358       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21359     } catch (std::out_of_range& e) {
21360       {
21361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21362       };
21363     } catch (std::exception& e) {
21364       {
21365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21366       };
21367     } catch (Dali::DaliException e) {
21368       {
21369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21370       };
21371     } catch (...) {
21372       {
21373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21374       };
21375     }
21376   }
21377
21378   jresult = (void *)result;
21379   return jresult;
21380 }
21381
21382
21383 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21384   char * jresult ;
21385   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21386   std::string *result = 0 ;
21387
21388   arg1 = (Dali::TypeInfo *)jarg1;
21389   {
21390     try {
21391       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21392     } catch (std::out_of_range& e) {
21393       {
21394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21395       };
21396     } catch (std::exception& e) {
21397       {
21398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21399       };
21400     } catch (Dali::DaliException e) {
21401       {
21402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21403       };
21404     } catch (...) {
21405       {
21406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21407       };
21408     }
21409   }
21410
21411   jresult = SWIG_csharp_string_callback(result->c_str());
21412   return jresult;
21413 }
21414
21415
21416 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21417   char * jresult ;
21418   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21419   std::string *result = 0 ;
21420
21421   arg1 = (Dali::TypeInfo *)jarg1;
21422   {
21423     try {
21424       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21425     } catch (std::out_of_range& e) {
21426       {
21427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21428       };
21429     } catch (std::exception& e) {
21430       {
21431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21432       };
21433     } catch (Dali::DaliException e) {
21434       {
21435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21436       };
21437     } catch (...) {
21438       {
21439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21440       };
21441     }
21442   }
21443
21444   jresult = SWIG_csharp_string_callback(result->c_str());
21445   return jresult;
21446 }
21447
21448
21449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21450   void * jresult ;
21451   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21452   Dali::BaseHandle result;
21453
21454   arg1 = (Dali::TypeInfo *)jarg1;
21455   {
21456     try {
21457       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21458     } catch (std::out_of_range& e) {
21459       {
21460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21461       };
21462     } catch (std::exception& e) {
21463       {
21464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21465       };
21466     } catch (Dali::DaliException e) {
21467       {
21468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21469       };
21470     } catch (...) {
21471       {
21472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21473       };
21474     }
21475   }
21476
21477   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21478   return jresult;
21479 }
21480
21481
21482 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21483   unsigned long jresult ;
21484   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21485   size_t result;
21486
21487   arg1 = (Dali::TypeInfo *)jarg1;
21488   {
21489     try {
21490       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21491     } catch (std::out_of_range& e) {
21492       {
21493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21494       };
21495     } catch (std::exception& e) {
21496       {
21497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21498       };
21499     } catch (Dali::DaliException e) {
21500       {
21501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21502       };
21503     } catch (...) {
21504       {
21505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21506       };
21507     }
21508   }
21509
21510   jresult = (unsigned long)result;
21511   return jresult;
21512 }
21513
21514
21515 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21516   char * jresult ;
21517   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21518   size_t arg2 ;
21519   std::string result;
21520
21521   arg1 = (Dali::TypeInfo *)jarg1;
21522   arg2 = (size_t)jarg2;
21523   {
21524     try {
21525       result = (arg1)->GetActionName(arg2);
21526     } catch (std::out_of_range& e) {
21527       {
21528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21529       };
21530     } catch (std::exception& e) {
21531       {
21532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21533       };
21534     } catch (Dali::DaliException e) {
21535       {
21536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21537       };
21538     } catch (...) {
21539       {
21540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21541       };
21542     }
21543   }
21544
21545   jresult = SWIG_csharp_string_callback((&result)->c_str());
21546   return jresult;
21547 }
21548
21549
21550 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21551   unsigned long jresult ;
21552   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21553   size_t result;
21554
21555   arg1 = (Dali::TypeInfo *)jarg1;
21556   {
21557     try {
21558       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21559     } catch (std::out_of_range& e) {
21560       {
21561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21562       };
21563     } catch (std::exception& e) {
21564       {
21565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21566       };
21567     } catch (Dali::DaliException e) {
21568       {
21569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21570       };
21571     } catch (...) {
21572       {
21573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21574       };
21575     }
21576   }
21577
21578   jresult = (unsigned long)result;
21579   return jresult;
21580 }
21581
21582
21583 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21584   char * jresult ;
21585   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21586   size_t arg2 ;
21587   std::string result;
21588
21589   arg1 = (Dali::TypeInfo *)jarg1;
21590   arg2 = (size_t)jarg2;
21591   {
21592     try {
21593       result = (arg1)->GetSignalName(arg2);
21594     } catch (std::out_of_range& e) {
21595       {
21596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21597       };
21598     } catch (std::exception& e) {
21599       {
21600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21601       };
21602     } catch (Dali::DaliException e) {
21603       {
21604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21605       };
21606     } catch (...) {
21607       {
21608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21609       };
21610     }
21611   }
21612
21613   jresult = SWIG_csharp_string_callback((&result)->c_str());
21614   return jresult;
21615 }
21616
21617
21618 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21619   unsigned long jresult ;
21620   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21621   size_t result;
21622
21623   arg1 = (Dali::TypeInfo *)jarg1;
21624   {
21625     try {
21626       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21627     } catch (std::out_of_range& e) {
21628       {
21629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21630       };
21631     } catch (std::exception& e) {
21632       {
21633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21634       };
21635     } catch (Dali::DaliException e) {
21636       {
21637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21638       };
21639     } catch (...) {
21640       {
21641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21642       };
21643     }
21644   }
21645
21646   jresult = (unsigned long)result;
21647   return jresult;
21648 }
21649
21650
21651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21652   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21653   Dali::Property::IndexContainer *arg2 = 0 ;
21654
21655   arg1 = (Dali::TypeInfo *)jarg1;
21656   arg2 = (Dali::Property::IndexContainer *)jarg2;
21657   if (!arg2) {
21658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21659     return ;
21660   }
21661   {
21662     try {
21663       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21664     } catch (std::out_of_range& e) {
21665       {
21666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21667       };
21668     } catch (std::exception& e) {
21669       {
21670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21671       };
21672     } catch (Dali::DaliException e) {
21673       {
21674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21675       };
21676     } catch (...) {
21677       {
21678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21679       };
21680     }
21681   }
21682
21683 }
21684
21685
21686 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21687   char * jresult ;
21688   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21689   Dali::Property::Index arg2 ;
21690   std::string *result = 0 ;
21691
21692   arg1 = (Dali::TypeInfo *)jarg1;
21693   arg2 = (Dali::Property::Index)jarg2;
21694   {
21695     try {
21696       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21697     } catch (std::out_of_range& e) {
21698       {
21699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21700       };
21701     } catch (std::exception& e) {
21702       {
21703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21704       };
21705     } catch (Dali::DaliException e) {
21706       {
21707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21708       };
21709     } catch (...) {
21710       {
21711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21712       };
21713     }
21714   }
21715
21716   jresult = SWIG_csharp_string_callback(result->c_str());
21717   return jresult;
21718 }
21719
21720
21721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21722   void * jresult ;
21723   Dali::TypeRegistry result;
21724
21725   {
21726     try {
21727       result = Dali::TypeRegistry::Get();
21728     } catch (std::out_of_range& e) {
21729       {
21730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21731       };
21732     } catch (std::exception& e) {
21733       {
21734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21735       };
21736     } catch (Dali::DaliException e) {
21737       {
21738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21739       };
21740     } catch (...) {
21741       {
21742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21743       };
21744     }
21745   }
21746
21747   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21748   return jresult;
21749 }
21750
21751
21752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21753   void * jresult ;
21754   Dali::TypeRegistry *result = 0 ;
21755
21756   {
21757     try {
21758       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21759     } catch (std::out_of_range& e) {
21760       {
21761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21762       };
21763     } catch (std::exception& e) {
21764       {
21765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21766       };
21767     } catch (Dali::DaliException e) {
21768       {
21769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21770       };
21771     } catch (...) {
21772       {
21773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21774       };
21775     }
21776   }
21777
21778   jresult = (void *)result;
21779   return jresult;
21780 }
21781
21782
21783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21784   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21785
21786   arg1 = (Dali::TypeRegistry *)jarg1;
21787   {
21788     try {
21789       delete arg1;
21790     } catch (std::out_of_range& e) {
21791       {
21792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21793       };
21794     } catch (std::exception& e) {
21795       {
21796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21797       };
21798     } catch (Dali::DaliException e) {
21799       {
21800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21801       };
21802     } catch (...) {
21803       {
21804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21805       };
21806     }
21807   }
21808
21809 }
21810
21811
21812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21813   void * jresult ;
21814   Dali::TypeRegistry *arg1 = 0 ;
21815   Dali::TypeRegistry *result = 0 ;
21816
21817   arg1 = (Dali::TypeRegistry *)jarg1;
21818   if (!arg1) {
21819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21820     return 0;
21821   }
21822   {
21823     try {
21824       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21825     } catch (std::out_of_range& e) {
21826       {
21827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21828       };
21829     } catch (std::exception& e) {
21830       {
21831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21832       };
21833     } catch (Dali::DaliException e) {
21834       {
21835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21836       };
21837     } catch (...) {
21838       {
21839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21840       };
21841     }
21842   }
21843
21844   jresult = (void *)result;
21845   return jresult;
21846 }
21847
21848
21849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21850   void * jresult ;
21851   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21852   Dali::TypeRegistry *arg2 = 0 ;
21853   Dali::TypeRegistry *result = 0 ;
21854
21855   arg1 = (Dali::TypeRegistry *)jarg1;
21856   arg2 = (Dali::TypeRegistry *)jarg2;
21857   if (!arg2) {
21858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21859     return 0;
21860   }
21861   {
21862     try {
21863       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21864     } catch (std::out_of_range& e) {
21865       {
21866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21867       };
21868     } catch (std::exception& e) {
21869       {
21870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21871       };
21872     } catch (Dali::DaliException e) {
21873       {
21874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21875       };
21876     } catch (...) {
21877       {
21878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21879       };
21880     }
21881   }
21882
21883   jresult = (void *)result;
21884   return jresult;
21885 }
21886
21887
21888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21889   void * jresult ;
21890   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21891   std::string *arg2 = 0 ;
21892   Dali::TypeInfo result;
21893
21894   arg1 = (Dali::TypeRegistry *)jarg1;
21895   if (!jarg2) {
21896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21897     return 0;
21898   }
21899   std::string arg2_str(jarg2);
21900   arg2 = &arg2_str;
21901   {
21902     try {
21903       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21904     } catch (std::out_of_range& e) {
21905       {
21906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21907       };
21908     } catch (std::exception& e) {
21909       {
21910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21911       };
21912     } catch (Dali::DaliException e) {
21913       {
21914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21915       };
21916     } catch (...) {
21917       {
21918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21919       };
21920     }
21921   }
21922
21923   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21924
21925   //argout typemap for const std::string&
21926
21927   return jresult;
21928 }
21929
21930
21931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21932   void * jresult ;
21933   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21934   std::type_info *arg2 = 0 ;
21935   Dali::TypeInfo result;
21936
21937   arg1 = (Dali::TypeRegistry *)jarg1;
21938   arg2 = (std::type_info *)jarg2;
21939   if (!arg2) {
21940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21941     return 0;
21942   }
21943   {
21944     try {
21945       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21946     } catch (std::out_of_range& e) {
21947       {
21948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21949       };
21950     } catch (std::exception& e) {
21951       {
21952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21953       };
21954     } catch (Dali::DaliException e) {
21955       {
21956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21957       };
21958     } catch (...) {
21959       {
21960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21961       };
21962     }
21963   }
21964
21965   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21966   return jresult;
21967 }
21968
21969
21970 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21971   unsigned long jresult ;
21972   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21973   size_t result;
21974
21975   arg1 = (Dali::TypeRegistry *)jarg1;
21976   {
21977     try {
21978       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21979     } catch (std::out_of_range& e) {
21980       {
21981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21982       };
21983     } catch (std::exception& e) {
21984       {
21985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21986       };
21987     } catch (Dali::DaliException e) {
21988       {
21989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21990       };
21991     } catch (...) {
21992       {
21993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21994       };
21995     }
21996   }
21997
21998   jresult = (unsigned long)result;
21999   return jresult;
22000 }
22001
22002
22003 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
22004   char * jresult ;
22005   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
22006   size_t arg2 ;
22007   std::string result;
22008
22009   arg1 = (Dali::TypeRegistry *)jarg1;
22010   arg2 = (size_t)jarg2;
22011   {
22012     try {
22013       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
22014     } catch (std::out_of_range& e) {
22015       {
22016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22017       };
22018     } catch (std::exception& e) {
22019       {
22020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22021       };
22022     } catch (Dali::DaliException e) {
22023       {
22024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22025       };
22026     } catch (...) {
22027       {
22028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22029       };
22030     }
22031   }
22032
22033   jresult = SWIG_csharp_string_callback((&result)->c_str());
22034   return jresult;
22035 }
22036
22037
22038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22039   void * jresult ;
22040   std::type_info *arg1 = 0 ;
22041   std::type_info *arg2 = 0 ;
22042   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22043   Dali::TypeRegistration *result = 0 ;
22044
22045   arg1 = (std::type_info *)jarg1;
22046   if (!arg1) {
22047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22048     return 0;
22049   }
22050   arg2 = (std::type_info *)jarg2;
22051   if (!arg2) {
22052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22053     return 0;
22054   }
22055   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22056   {
22057     try {
22058       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22059     } catch (std::out_of_range& e) {
22060       {
22061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22062       };
22063     } catch (std::exception& e) {
22064       {
22065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22066       };
22067     } catch (Dali::DaliException e) {
22068       {
22069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22070       };
22071     } catch (...) {
22072       {
22073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22074       };
22075     }
22076   }
22077
22078   jresult = (void *)result;
22079   return jresult;
22080 }
22081
22082
22083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22084   void * jresult ;
22085   std::type_info *arg1 = 0 ;
22086   std::type_info *arg2 = 0 ;
22087   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22088   bool arg4 ;
22089   Dali::TypeRegistration *result = 0 ;
22090
22091   arg1 = (std::type_info *)jarg1;
22092   if (!arg1) {
22093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22094     return 0;
22095   }
22096   arg2 = (std::type_info *)jarg2;
22097   if (!arg2) {
22098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22099     return 0;
22100   }
22101   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22102   arg4 = jarg4 ? true : false;
22103   {
22104     try {
22105       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22106     } catch (std::out_of_range& e) {
22107       {
22108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22109       };
22110     } catch (std::exception& e) {
22111       {
22112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22113       };
22114     } catch (Dali::DaliException e) {
22115       {
22116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22117       };
22118     } catch (...) {
22119       {
22120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22121       };
22122     }
22123   }
22124
22125   jresult = (void *)result;
22126   return jresult;
22127 }
22128
22129
22130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22131   void * jresult ;
22132   std::string *arg1 = 0 ;
22133   std::type_info *arg2 = 0 ;
22134   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22135   Dali::TypeRegistration *result = 0 ;
22136
22137   if (!jarg1) {
22138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22139     return 0;
22140   }
22141   std::string arg1_str(jarg1);
22142   arg1 = &arg1_str;
22143   arg2 = (std::type_info *)jarg2;
22144   if (!arg2) {
22145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22146     return 0;
22147   }
22148   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22149   {
22150     try {
22151       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22152     } catch (std::out_of_range& e) {
22153       {
22154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22155       };
22156     } catch (std::exception& e) {
22157       {
22158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22159       };
22160     } catch (Dali::DaliException e) {
22161       {
22162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22163       };
22164     } catch (...) {
22165       {
22166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22167       };
22168     }
22169   }
22170
22171   jresult = (void *)result;
22172
22173   //argout typemap for const std::string&
22174
22175   return jresult;
22176 }
22177
22178
22179 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22180   char * jresult ;
22181   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22182   std::string result;
22183
22184   arg1 = (Dali::TypeRegistration *)jarg1;
22185   {
22186     try {
22187       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22188     } catch (std::out_of_range& e) {
22189       {
22190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22191       };
22192     } catch (std::exception& e) {
22193       {
22194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22195       };
22196     } catch (Dali::DaliException e) {
22197       {
22198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22199       };
22200     } catch (...) {
22201       {
22202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22203       };
22204     }
22205   }
22206
22207   jresult = SWIG_csharp_string_callback((&result)->c_str());
22208   return jresult;
22209 }
22210
22211
22212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22213   std::string *arg1 = 0 ;
22214   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22215
22216   if (!jarg1) {
22217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22218     return ;
22219   }
22220   std::string arg1_str(jarg1);
22221   arg1 = &arg1_str;
22222   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22223   {
22224     try {
22225       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22226     } catch (std::out_of_range& e) {
22227       {
22228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22229       };
22230     } catch (std::exception& e) {
22231       {
22232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22233       };
22234     } catch (Dali::DaliException e) {
22235       {
22236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22237       };
22238     } catch (...) {
22239       {
22240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22241       };
22242     }
22243   }
22244
22245
22246   //argout typemap for const std::string&
22247
22248 }
22249
22250
22251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22252   std::string *arg1 = 0 ;
22253   std::string *arg2 = 0 ;
22254   int arg3 ;
22255   Dali::Property::Type arg4 ;
22256   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22257   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22258
22259   if (!jarg1) {
22260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22261     return ;
22262   }
22263   std::string arg1_str(jarg1);
22264   arg1 = &arg1_str;
22265   if (!jarg2) {
22266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22267     return ;
22268   }
22269   std::string arg2_str(jarg2);
22270   arg2 = &arg2_str;
22271   arg3 = (int)jarg3;
22272   arg4 = (Dali::Property::Type)jarg4;
22273   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22274   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22275   {
22276     try {
22277       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22278     } catch (std::out_of_range& e) {
22279       {
22280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22281       };
22282     } catch (std::exception& e) {
22283       {
22284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22285       };
22286     } catch (Dali::DaliException e) {
22287       {
22288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22289       };
22290     } catch (...) {
22291       {
22292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22293       };
22294     }
22295   }
22296
22297
22298   //argout typemap for const std::string&
22299
22300
22301   //argout typemap for const std::string&
22302
22303 }
22304
22305
22306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22307   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22308
22309   arg1 = (Dali::TypeRegistration *)jarg1;
22310   {
22311     try {
22312       delete arg1;
22313     } catch (std::out_of_range& e) {
22314       {
22315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22316       };
22317     } catch (std::exception& e) {
22318       {
22319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22320       };
22321     } catch (Dali::DaliException e) {
22322       {
22323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22324       };
22325     } catch (...) {
22326       {
22327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22328       };
22329     }
22330   }
22331
22332 }
22333
22334
22335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22336   void * jresult ;
22337   Dali::TypeRegistration *arg1 = 0 ;
22338   std::string *arg2 = 0 ;
22339   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22340   Dali::SignalConnectorType *result = 0 ;
22341
22342   arg1 = (Dali::TypeRegistration *)jarg1;
22343   if (!arg1) {
22344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22345     return 0;
22346   }
22347   if (!jarg2) {
22348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22349     return 0;
22350   }
22351   std::string arg2_str(jarg2);
22352   arg2 = &arg2_str;
22353   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22354   {
22355     try {
22356       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22357     } catch (std::out_of_range& e) {
22358       {
22359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22360       };
22361     } catch (std::exception& e) {
22362       {
22363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22364       };
22365     } catch (Dali::DaliException e) {
22366       {
22367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22368       };
22369     } catch (...) {
22370       {
22371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22372       };
22373     }
22374   }
22375
22376   jresult = (void *)result;
22377
22378   //argout typemap for const std::string&
22379
22380   return jresult;
22381 }
22382
22383
22384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22385   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22386
22387   arg1 = (Dali::SignalConnectorType *)jarg1;
22388   {
22389     try {
22390       delete arg1;
22391     } catch (std::out_of_range& e) {
22392       {
22393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22394       };
22395     } catch (std::exception& e) {
22396       {
22397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22398       };
22399     } catch (Dali::DaliException e) {
22400       {
22401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22402       };
22403     } catch (...) {
22404       {
22405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22406       };
22407     }
22408   }
22409
22410 }
22411
22412
22413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22414   void * jresult ;
22415   Dali::TypeRegistration *arg1 = 0 ;
22416   std::string *arg2 = 0 ;
22417   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22418   Dali::TypeAction *result = 0 ;
22419
22420   arg1 = (Dali::TypeRegistration *)jarg1;
22421   if (!arg1) {
22422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22423     return 0;
22424   }
22425   if (!jarg2) {
22426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22427     return 0;
22428   }
22429   std::string arg2_str(jarg2);
22430   arg2 = &arg2_str;
22431   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22432   {
22433     try {
22434       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22435     } catch (std::out_of_range& e) {
22436       {
22437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22438       };
22439     } catch (std::exception& e) {
22440       {
22441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22442       };
22443     } catch (Dali::DaliException e) {
22444       {
22445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22446       };
22447     } catch (...) {
22448       {
22449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22450       };
22451     }
22452   }
22453
22454   jresult = (void *)result;
22455
22456   //argout typemap for const std::string&
22457
22458   return jresult;
22459 }
22460
22461
22462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22463   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22464
22465   arg1 = (Dali::TypeAction *)jarg1;
22466   {
22467     try {
22468       delete arg1;
22469     } catch (std::out_of_range& e) {
22470       {
22471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22472       };
22473     } catch (std::exception& e) {
22474       {
22475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22476       };
22477     } catch (Dali::DaliException e) {
22478       {
22479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22480       };
22481     } catch (...) {
22482       {
22483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22484       };
22485     }
22486   }
22487
22488 }
22489
22490
22491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22492   void * jresult ;
22493   Dali::TypeRegistration *arg1 = 0 ;
22494   std::string *arg2 = 0 ;
22495   Dali::Property::Index arg3 ;
22496   Dali::Property::Type arg4 ;
22497   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22498   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22499   Dali::PropertyRegistration *result = 0 ;
22500
22501   arg1 = (Dali::TypeRegistration *)jarg1;
22502   if (!arg1) {
22503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22504     return 0;
22505   }
22506   if (!jarg2) {
22507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22508     return 0;
22509   }
22510   std::string arg2_str(jarg2);
22511   arg2 = &arg2_str;
22512   arg3 = (Dali::Property::Index)jarg3;
22513   arg4 = (Dali::Property::Type)jarg4;
22514   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22515   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22516   {
22517     try {
22518       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22519     } catch (std::out_of_range& e) {
22520       {
22521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22522       };
22523     } catch (std::exception& e) {
22524       {
22525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22526       };
22527     } catch (Dali::DaliException e) {
22528       {
22529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22530       };
22531     } catch (...) {
22532       {
22533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22534       };
22535     }
22536   }
22537
22538   jresult = (void *)result;
22539
22540   //argout typemap for const std::string&
22541
22542   return jresult;
22543 }
22544
22545
22546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22547   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22548
22549   arg1 = (Dali::PropertyRegistration *)jarg1;
22550   {
22551     try {
22552       delete arg1;
22553     } catch (std::out_of_range& e) {
22554       {
22555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22556       };
22557     } catch (std::exception& e) {
22558       {
22559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22560       };
22561     } catch (Dali::DaliException e) {
22562       {
22563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22564       };
22565     } catch (...) {
22566       {
22567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22568       };
22569     }
22570   }
22571
22572 }
22573
22574
22575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22576   void * jresult ;
22577   Dali::TypeRegistration *arg1 = 0 ;
22578   std::string *arg2 = 0 ;
22579   Dali::Property::Index arg3 ;
22580   Dali::Property::Type arg4 ;
22581   Dali::AnimatablePropertyRegistration *result = 0 ;
22582
22583   arg1 = (Dali::TypeRegistration *)jarg1;
22584   if (!arg1) {
22585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22586     return 0;
22587   }
22588   if (!jarg2) {
22589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22590     return 0;
22591   }
22592   std::string arg2_str(jarg2);
22593   arg2 = &arg2_str;
22594   arg3 = (Dali::Property::Index)jarg3;
22595   arg4 = (Dali::Property::Type)jarg4;
22596   {
22597     try {
22598       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22599     } catch (std::out_of_range& e) {
22600       {
22601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22602       };
22603     } catch (std::exception& e) {
22604       {
22605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22606       };
22607     } catch (Dali::DaliException e) {
22608       {
22609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22610       };
22611     } catch (...) {
22612       {
22613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22614       };
22615     }
22616   }
22617
22618   jresult = (void *)result;
22619
22620   //argout typemap for const std::string&
22621
22622   return jresult;
22623 }
22624
22625
22626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22627   void * jresult ;
22628   Dali::TypeRegistration *arg1 = 0 ;
22629   std::string *arg2 = 0 ;
22630   Dali::Property::Index arg3 ;
22631   Dali::Property::Value *arg4 = 0 ;
22632   Dali::AnimatablePropertyRegistration *result = 0 ;
22633
22634   arg1 = (Dali::TypeRegistration *)jarg1;
22635   if (!arg1) {
22636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22637     return 0;
22638   }
22639   if (!jarg2) {
22640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22641     return 0;
22642   }
22643   std::string arg2_str(jarg2);
22644   arg2 = &arg2_str;
22645   arg3 = (Dali::Property::Index)jarg3;
22646   arg4 = (Dali::Property::Value *)jarg4;
22647   if (!arg4) {
22648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22649     return 0;
22650   }
22651   {
22652     try {
22653       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22654     } catch (std::out_of_range& e) {
22655       {
22656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22657       };
22658     } catch (std::exception& e) {
22659       {
22660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22661       };
22662     } catch (Dali::DaliException e) {
22663       {
22664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22665       };
22666     } catch (...) {
22667       {
22668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22669       };
22670     }
22671   }
22672
22673   jresult = (void *)result;
22674
22675   //argout typemap for const std::string&
22676
22677   return jresult;
22678 }
22679
22680
22681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22682   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22683
22684   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22685   {
22686     try {
22687       delete arg1;
22688     } catch (std::out_of_range& e) {
22689       {
22690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22691       };
22692     } catch (std::exception& e) {
22693       {
22694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22695       };
22696     } catch (Dali::DaliException e) {
22697       {
22698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22699       };
22700     } catch (...) {
22701       {
22702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22703       };
22704     }
22705   }
22706
22707 }
22708
22709
22710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22711   void * jresult ;
22712   Dali::TypeRegistration *arg1 = 0 ;
22713   std::string *arg2 = 0 ;
22714   Dali::Property::Index arg3 ;
22715   Dali::Property::Index arg4 ;
22716   unsigned int arg5 ;
22717   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22718
22719   arg1 = (Dali::TypeRegistration *)jarg1;
22720   if (!arg1) {
22721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22722     return 0;
22723   }
22724   if (!jarg2) {
22725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22726     return 0;
22727   }
22728   std::string arg2_str(jarg2);
22729   arg2 = &arg2_str;
22730   arg3 = (Dali::Property::Index)jarg3;
22731   arg4 = (Dali::Property::Index)jarg4;
22732   arg5 = (unsigned int)jarg5;
22733   {
22734     try {
22735       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22736     } catch (std::out_of_range& e) {
22737       {
22738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22739       };
22740     } catch (std::exception& e) {
22741       {
22742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22743       };
22744     } catch (Dali::DaliException e) {
22745       {
22746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22747       };
22748     } catch (...) {
22749       {
22750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22751       };
22752     }
22753   }
22754
22755   jresult = (void *)result;
22756
22757   //argout typemap for const std::string&
22758
22759   return jresult;
22760 }
22761
22762
22763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22764   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22765
22766   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22767   {
22768     try {
22769       delete arg1;
22770     } catch (std::out_of_range& e) {
22771       {
22772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22773       };
22774     } catch (std::exception& e) {
22775       {
22776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22777       };
22778     } catch (Dali::DaliException e) {
22779       {
22780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22781       };
22782     } catch (...) {
22783       {
22784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22785       };
22786     }
22787   }
22788
22789 }
22790
22791
22792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22793   void * jresult ;
22794   Dali::TypeRegistration *arg1 = 0 ;
22795   std::string *arg2 = 0 ;
22796   Dali::Property::Index arg3 ;
22797   Dali::Property::Type arg4 ;
22798   Dali::ChildPropertyRegistration *result = 0 ;
22799
22800   arg1 = (Dali::TypeRegistration *)jarg1;
22801   if (!arg1) {
22802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22803     return 0;
22804   }
22805   if (!jarg2) {
22806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22807     return 0;
22808   }
22809   std::string arg2_str(jarg2);
22810   arg2 = &arg2_str;
22811   arg3 = (Dali::Property::Index)jarg3;
22812   arg4 = (Dali::Property::Type)jarg4;
22813   {
22814     try {
22815       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22816     } catch (std::out_of_range& e) {
22817       {
22818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22819       };
22820     } catch (std::exception& e) {
22821       {
22822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22823       };
22824     } catch (Dali::DaliException e) {
22825       {
22826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22827       };
22828     } catch (...) {
22829       {
22830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22831       };
22832     }
22833   }
22834
22835   jresult = (void *)result;
22836
22837   //argout typemap for const std::string&
22838
22839   return jresult;
22840 }
22841
22842
22843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22844   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22845
22846   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22847   {
22848     try {
22849       delete arg1;
22850     } catch (std::out_of_range& e) {
22851       {
22852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22853       };
22854     } catch (std::exception& e) {
22855       {
22856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22857       };
22858     } catch (Dali::DaliException e) {
22859       {
22860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22861       };
22862     } catch (...) {
22863       {
22864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22865       };
22866     }
22867   }
22868
22869 }
22870
22871
22872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22873   unsigned int jresult ;
22874   std::string *arg1 = 0 ;
22875   std::type_info *arg2 = 0 ;
22876   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22877   bool result;
22878
22879   if (!jarg1) {
22880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22881     return 0;
22882   }
22883   std::string arg1_str(jarg1);
22884   arg1 = &arg1_str;
22885   arg2 = (std::type_info *)jarg2;
22886   if (!arg2) {
22887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22888     return 0;
22889   }
22890   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22891   {
22892     try {
22893       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22894     } catch (std::out_of_range& e) {
22895       {
22896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22897       };
22898     } catch (std::exception& e) {
22899       {
22900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22901       };
22902     } catch (Dali::DaliException e) {
22903       {
22904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22905       };
22906     } catch (...) {
22907       {
22908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22909       };
22910     }
22911   }
22912
22913   jresult = result;
22914
22915   //argout typemap for const std::string&
22916
22917   return jresult;
22918 }
22919
22920
22921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22922   unsigned int jresult ;
22923   std::string *arg1 = 0 ;
22924   std::string *arg2 = 0 ;
22925   Dali::Property::Index arg3 ;
22926   Dali::Property::Type arg4 ;
22927   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22928   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22929   bool result;
22930
22931   if (!jarg1) {
22932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22933     return 0;
22934   }
22935   std::string arg1_str(jarg1);
22936   arg1 = &arg1_str;
22937   if (!jarg2) {
22938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22939     return 0;
22940   }
22941   std::string arg2_str(jarg2);
22942   arg2 = &arg2_str;
22943   arg3 = (Dali::Property::Index)jarg3;
22944   arg4 = (Dali::Property::Type)jarg4;
22945   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22946   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22947   {
22948     try {
22949       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22950     } catch (std::out_of_range& e) {
22951       {
22952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22953       };
22954     } catch (std::exception& e) {
22955       {
22956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22957       };
22958     } catch (Dali::DaliException e) {
22959       {
22960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22961       };
22962     } catch (...) {
22963       {
22964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22965       };
22966     }
22967   }
22968
22969   jresult = result;
22970
22971   //argout typemap for const std::string&
22972
22973
22974   //argout typemap for const std::string&
22975
22976   return jresult;
22977 }
22978
22979
22980 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22981   float jresult ;
22982   float result;
22983
22984   result = (float)(float)Dali::ParentOrigin::TOP;
22985   jresult = result;
22986   return jresult;
22987 }
22988
22989
22990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22991   float jresult ;
22992   float result;
22993
22994   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22995   jresult = result;
22996   return jresult;
22997 }
22998
22999
23000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
23001   float jresult ;
23002   float result;
23003
23004   result = (float)(float)Dali::ParentOrigin::LEFT;
23005   jresult = result;
23006   return jresult;
23007 }
23008
23009
23010 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
23011   float jresult ;
23012   float result;
23013
23014   result = (float)(float)Dali::ParentOrigin::RIGHT;
23015   jresult = result;
23016   return jresult;
23017 }
23018
23019
23020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
23021   float jresult ;
23022   float result;
23023
23024   result = (float)(float)Dali::ParentOrigin::MIDDLE;
23025   jresult = result;
23026   return jresult;
23027 }
23028
23029
23030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
23031   void * jresult ;
23032   Dali::Vector3 *result = 0 ;
23033
23034   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23035   jresult = (void *)result;
23036   return jresult;
23037 }
23038
23039
23040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23041   void * jresult ;
23042   Dali::Vector3 *result = 0 ;
23043
23044   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23045   jresult = (void *)result;
23046   return jresult;
23047 }
23048
23049
23050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23051   void * jresult ;
23052   Dali::Vector3 *result = 0 ;
23053
23054   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23055   jresult = (void *)result;
23056   return jresult;
23057 }
23058
23059
23060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23061   void * jresult ;
23062   Dali::Vector3 *result = 0 ;
23063
23064   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23065   jresult = (void *)result;
23066   return jresult;
23067 }
23068
23069
23070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23071   void * jresult ;
23072   Dali::Vector3 *result = 0 ;
23073
23074   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23075   jresult = (void *)result;
23076   return jresult;
23077 }
23078
23079
23080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23081   void * jresult ;
23082   Dali::Vector3 *result = 0 ;
23083
23084   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23085   jresult = (void *)result;
23086   return jresult;
23087 }
23088
23089
23090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23091   void * jresult ;
23092   Dali::Vector3 *result = 0 ;
23093
23094   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23095   jresult = (void *)result;
23096   return jresult;
23097 }
23098
23099
23100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23101   void * jresult ;
23102   Dali::Vector3 *result = 0 ;
23103
23104   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23105   jresult = (void *)result;
23106   return jresult;
23107 }
23108
23109
23110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23111   void * jresult ;
23112   Dali::Vector3 *result = 0 ;
23113
23114   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23115   jresult = (void *)result;
23116   return jresult;
23117 }
23118
23119
23120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23121   float jresult ;
23122   float result;
23123
23124   result = (float)(float)Dali::AnchorPoint::TOP;
23125   jresult = result;
23126   return jresult;
23127 }
23128
23129
23130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23131   float jresult ;
23132   float result;
23133
23134   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23135   jresult = result;
23136   return jresult;
23137 }
23138
23139
23140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23141   float jresult ;
23142   float result;
23143
23144   result = (float)(float)Dali::AnchorPoint::LEFT;
23145   jresult = result;
23146   return jresult;
23147 }
23148
23149
23150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23151   float jresult ;
23152   float result;
23153
23154   result = (float)(float)Dali::AnchorPoint::RIGHT;
23155   jresult = result;
23156   return jresult;
23157 }
23158
23159
23160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23161   float jresult ;
23162   float result;
23163
23164   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23165   jresult = result;
23166   return jresult;
23167 }
23168
23169
23170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23171   void * jresult ;
23172   Dali::Vector3 *result = 0 ;
23173
23174   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23175   jresult = (void *)result;
23176   return jresult;
23177 }
23178
23179
23180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23181   void * jresult ;
23182   Dali::Vector3 *result = 0 ;
23183
23184   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23185   jresult = (void *)result;
23186   return jresult;
23187 }
23188
23189
23190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23191   void * jresult ;
23192   Dali::Vector3 *result = 0 ;
23193
23194   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23195   jresult = (void *)result;
23196   return jresult;
23197 }
23198
23199
23200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23201   void * jresult ;
23202   Dali::Vector3 *result = 0 ;
23203
23204   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23205   jresult = (void *)result;
23206   return jresult;
23207 }
23208
23209
23210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23211   void * jresult ;
23212   Dali::Vector3 *result = 0 ;
23213
23214   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23215   jresult = (void *)result;
23216   return jresult;
23217 }
23218
23219
23220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23221   void * jresult ;
23222   Dali::Vector3 *result = 0 ;
23223
23224   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23225   jresult = (void *)result;
23226   return jresult;
23227 }
23228
23229
23230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23231   void * jresult ;
23232   Dali::Vector3 *result = 0 ;
23233
23234   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23235   jresult = (void *)result;
23236   return jresult;
23237 }
23238
23239
23240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23241   void * jresult ;
23242   Dali::Vector3 *result = 0 ;
23243
23244   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23245   jresult = (void *)result;
23246   return jresult;
23247 }
23248
23249
23250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23251   void * jresult ;
23252   Dali::Vector3 *result = 0 ;
23253
23254   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23255   jresult = (void *)result;
23256   return jresult;
23257 }
23258
23259
23260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23261   void * jresult ;
23262   Dali::Vector4 *result = 0 ;
23263
23264   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23265   jresult = (void *)result;
23266   return jresult;
23267 }
23268
23269
23270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23271   void * jresult ;
23272   Dali::Vector4 *result = 0 ;
23273
23274   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23275   jresult = (void *)result;
23276   return jresult;
23277 }
23278
23279
23280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23281   void * jresult ;
23282   Dali::Vector4 *result = 0 ;
23283
23284   result = (Dali::Vector4 *)&Dali::Color::RED;
23285   jresult = (void *)result;
23286   return jresult;
23287 }
23288
23289
23290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23291   void * jresult ;
23292   Dali::Vector4 *result = 0 ;
23293
23294   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23295   jresult = (void *)result;
23296   return jresult;
23297 }
23298
23299
23300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23301   void * jresult ;
23302   Dali::Vector4 *result = 0 ;
23303
23304   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23305   jresult = (void *)result;
23306   return jresult;
23307 }
23308
23309
23310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23311   void * jresult ;
23312   Dali::Vector4 *result = 0 ;
23313
23314   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23315   jresult = (void *)result;
23316   return jresult;
23317 }
23318
23319
23320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23321   void * jresult ;
23322   Dali::Vector4 *result = 0 ;
23323
23324   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23325   jresult = (void *)result;
23326   return jresult;
23327 }
23328
23329
23330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23331   void * jresult ;
23332   Dali::Vector4 *result = 0 ;
23333
23334   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23335   jresult = (void *)result;
23336   return jresult;
23337 }
23338
23339
23340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23341   void * jresult ;
23342   Dali::Vector4 *result = 0 ;
23343
23344   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23345   jresult = (void *)result;
23346   return jresult;
23347 }
23348
23349
23350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23351   float jresult ;
23352   float result;
23353
23354   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23355   jresult = result;
23356   return jresult;
23357 }
23358
23359
23360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23361   float jresult ;
23362   float result;
23363
23364   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23365   jresult = result;
23366   return jresult;
23367 }
23368
23369
23370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23371   float jresult ;
23372   float result;
23373
23374   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23375   jresult = result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23381   float jresult ;
23382   float result;
23383
23384   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23385   jresult = result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23391   float jresult ;
23392   float result;
23393
23394   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23395   jresult = result;
23396   return jresult;
23397 }
23398
23399
23400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23401   float jresult ;
23402   float result;
23403
23404   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23405   jresult = result;
23406   return jresult;
23407 }
23408
23409
23410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23411   float jresult ;
23412   float result;
23413
23414   result = (float)(float)Dali::Math::PI;
23415   jresult = result;
23416   return jresult;
23417 }
23418
23419
23420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23421   float jresult ;
23422   float result;
23423
23424   result = (float)(float)Dali::Math::PI_2;
23425   jresult = result;
23426   return jresult;
23427 }
23428
23429
23430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23431   float jresult ;
23432   float result;
23433
23434   result = (float)(float)Dali::Math::PI_4;
23435   jresult = result;
23436   return jresult;
23437 }
23438
23439
23440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23441   float jresult ;
23442   float result;
23443
23444   result = (float)(float)Dali::Math::PI_OVER_180;
23445   jresult = result;
23446   return jresult;
23447 }
23448
23449
23450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23451   float jresult ;
23452   float result;
23453
23454   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23455   jresult = result;
23456   return jresult;
23457 }
23458
23459
23460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23461   int jresult ;
23462   Dali::ResizePolicy::Type result;
23463
23464   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23465   jresult = (int)result;
23466   return jresult;
23467 }
23468
23469
23470 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23471   unsigned long jresult ;
23472   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23473   Dali::VectorBase::SizeType result;
23474
23475   arg1 = (Dali::VectorBase *)jarg1;
23476   {
23477     try {
23478       result = ((Dali::VectorBase const *)arg1)->Count();
23479     } catch (std::out_of_range& e) {
23480       {
23481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23482       };
23483     } catch (std::exception& e) {
23484       {
23485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23486       };
23487     } catch (Dali::DaliException e) {
23488       {
23489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23490       };
23491     } catch (...) {
23492       {
23493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23494       };
23495     }
23496   }
23497
23498   jresult = (unsigned long)result;
23499   return jresult;
23500 }
23501
23502
23503 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23504   unsigned long jresult ;
23505   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23506   Dali::VectorBase::SizeType result;
23507
23508   arg1 = (Dali::VectorBase *)jarg1;
23509   {
23510     try {
23511       result = ((Dali::VectorBase const *)arg1)->Size();
23512     } catch (std::out_of_range& e) {
23513       {
23514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23515       };
23516     } catch (std::exception& e) {
23517       {
23518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23519       };
23520     } catch (Dali::DaliException e) {
23521       {
23522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23523       };
23524     } catch (...) {
23525       {
23526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23527       };
23528     }
23529   }
23530
23531   jresult = (unsigned long)result;
23532   return jresult;
23533 }
23534
23535
23536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23537   unsigned int jresult ;
23538   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23539   bool result;
23540
23541   arg1 = (Dali::VectorBase *)jarg1;
23542   {
23543     try {
23544       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23545     } catch (std::out_of_range& e) {
23546       {
23547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23548       };
23549     } catch (std::exception& e) {
23550       {
23551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23552       };
23553     } catch (Dali::DaliException e) {
23554       {
23555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23556       };
23557     } catch (...) {
23558       {
23559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23560       };
23561     }
23562   }
23563
23564   jresult = result;
23565   return jresult;
23566 }
23567
23568
23569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23570   unsigned long jresult ;
23571   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23572   Dali::VectorBase::SizeType result;
23573
23574   arg1 = (Dali::VectorBase *)jarg1;
23575   {
23576     try {
23577       result = ((Dali::VectorBase const *)arg1)->Capacity();
23578     } catch (std::out_of_range& e) {
23579       {
23580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23581       };
23582     } catch (std::exception& e) {
23583       {
23584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23585       };
23586     } catch (Dali::DaliException e) {
23587       {
23588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23589       };
23590     } catch (...) {
23591       {
23592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23593       };
23594     }
23595   }
23596
23597   jresult = (unsigned long)result;
23598   return jresult;
23599 }
23600
23601
23602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23603   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23604
23605   arg1 = (Dali::VectorBase *)jarg1;
23606   {
23607     try {
23608       (arg1)->Release();
23609     } catch (std::out_of_range& e) {
23610       {
23611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23612       };
23613     } catch (std::exception& e) {
23614       {
23615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23616       };
23617     } catch (Dali::DaliException e) {
23618       {
23619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23620       };
23621     } catch (...) {
23622       {
23623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23624       };
23625     }
23626   }
23627
23628 }
23629
23630
23631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23632   void * jresult ;
23633   Dali::Image *result = 0 ;
23634
23635   {
23636     try {
23637       result = (Dali::Image *)new Dali::Image();
23638     } catch (std::out_of_range& e) {
23639       {
23640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23641       };
23642     } catch (std::exception& e) {
23643       {
23644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23645       };
23646     } catch (Dali::DaliException e) {
23647       {
23648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23649       };
23650     } catch (...) {
23651       {
23652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23653       };
23654     }
23655   }
23656
23657   jresult = (void *)result;
23658   return jresult;
23659 }
23660
23661
23662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23663   Dali::Image *arg1 = (Dali::Image *) 0 ;
23664
23665   arg1 = (Dali::Image *)jarg1;
23666   {
23667     try {
23668       delete arg1;
23669     } catch (std::out_of_range& e) {
23670       {
23671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23672       };
23673     } catch (std::exception& e) {
23674       {
23675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23676       };
23677     } catch (Dali::DaliException e) {
23678       {
23679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23680       };
23681     } catch (...) {
23682       {
23683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23684       };
23685     }
23686   }
23687
23688 }
23689
23690
23691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23692   void * jresult ;
23693   Dali::Image *arg1 = 0 ;
23694   Dali::Image *result = 0 ;
23695
23696   arg1 = (Dali::Image *)jarg1;
23697   if (!arg1) {
23698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23699     return 0;
23700   }
23701   {
23702     try {
23703       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23704     } catch (std::out_of_range& e) {
23705       {
23706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23707       };
23708     } catch (std::exception& e) {
23709       {
23710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23711       };
23712     } catch (Dali::DaliException e) {
23713       {
23714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23715       };
23716     } catch (...) {
23717       {
23718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23719       };
23720     }
23721   }
23722
23723   jresult = (void *)result;
23724   return jresult;
23725 }
23726
23727
23728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23729   void * jresult ;
23730   Dali::Image *arg1 = (Dali::Image *) 0 ;
23731   Dali::Image *arg2 = 0 ;
23732   Dali::Image *result = 0 ;
23733
23734   arg1 = (Dali::Image *)jarg1;
23735   arg2 = (Dali::Image *)jarg2;
23736   if (!arg2) {
23737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23738     return 0;
23739   }
23740   {
23741     try {
23742       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23743     } catch (std::out_of_range& e) {
23744       {
23745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23746       };
23747     } catch (std::exception& e) {
23748       {
23749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23750       };
23751     } catch (Dali::DaliException e) {
23752       {
23753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23754       };
23755     } catch (...) {
23756       {
23757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23758       };
23759     }
23760   }
23761
23762   jresult = (void *)result;
23763   return jresult;
23764 }
23765
23766
23767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23768   void * jresult ;
23769   Dali::BaseHandle arg1 ;
23770   Dali::BaseHandle *argp1 ;
23771   Dali::Image result;
23772
23773   argp1 = (Dali::BaseHandle *)jarg1;
23774   if (!argp1) {
23775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23776     return 0;
23777   }
23778   arg1 = *argp1;
23779   {
23780     try {
23781       result = Dali::Image::DownCast(arg1);
23782     } catch (std::out_of_range& e) {
23783       {
23784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23785       };
23786     } catch (std::exception& e) {
23787       {
23788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23789       };
23790     } catch (Dali::DaliException e) {
23791       {
23792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23793       };
23794     } catch (...) {
23795       {
23796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23797       };
23798     }
23799   }
23800
23801   jresult = new Dali::Image((const Dali::Image &)result);
23802   return jresult;
23803 }
23804
23805
23806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23807   unsigned int jresult ;
23808   Dali::Image *arg1 = (Dali::Image *) 0 ;
23809   unsigned int result;
23810
23811   arg1 = (Dali::Image *)jarg1;
23812   {
23813     try {
23814       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23815     } catch (std::out_of_range& e) {
23816       {
23817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23818       };
23819     } catch (std::exception& e) {
23820       {
23821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23822       };
23823     } catch (Dali::DaliException e) {
23824       {
23825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23826       };
23827     } catch (...) {
23828       {
23829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23830       };
23831     }
23832   }
23833
23834   jresult = result;
23835   return jresult;
23836 }
23837
23838
23839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23840   unsigned int jresult ;
23841   Dali::Image *arg1 = (Dali::Image *) 0 ;
23842   unsigned int result;
23843
23844   arg1 = (Dali::Image *)jarg1;
23845   {
23846     try {
23847       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23848     } catch (std::out_of_range& e) {
23849       {
23850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23851       };
23852     } catch (std::exception& e) {
23853       {
23854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23855       };
23856     } catch (Dali::DaliException e) {
23857       {
23858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23859       };
23860     } catch (...) {
23861       {
23862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23863       };
23864     }
23865   }
23866
23867   jresult = result;
23868   return jresult;
23869 }
23870
23871
23872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23873   void * jresult ;
23874   Dali::Image *arg1 = (Dali::Image *) 0 ;
23875   Dali::Image::ImageSignalType *result = 0 ;
23876
23877   arg1 = (Dali::Image *)jarg1;
23878   {
23879     try {
23880       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23881     } catch (std::out_of_range& e) {
23882       {
23883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23884       };
23885     } catch (std::exception& e) {
23886       {
23887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23888       };
23889     } catch (Dali::DaliException e) {
23890       {
23891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23892       };
23893     } catch (...) {
23894       {
23895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23896       };
23897     }
23898   }
23899
23900   jresult = (void *)result;
23901   return jresult;
23902 }
23903
23904
23905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23906   int jresult ;
23907   Dali::Pixel::Format result;
23908
23909   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23910   jresult = (int)result;
23911   return jresult;
23912 }
23913
23914
23915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23916   int jresult ;
23917   Dali::Pixel::Format result;
23918
23919   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23920   jresult = (int)result;
23921   return jresult;
23922 }
23923
23924
23925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23926   unsigned int jresult ;
23927   Dali::Pixel::Format arg1 ;
23928   bool result;
23929
23930   arg1 = (Dali::Pixel::Format)jarg1;
23931   {
23932     try {
23933       result = (bool)Dali::Pixel::HasAlpha(arg1);
23934     } catch (std::out_of_range& e) {
23935       {
23936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23937       };
23938     } catch (std::exception& e) {
23939       {
23940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23941       };
23942     } catch (Dali::DaliException e) {
23943       {
23944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23945       };
23946     } catch (...) {
23947       {
23948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23949       };
23950     }
23951   }
23952
23953   jresult = result;
23954   return jresult;
23955 }
23956
23957
23958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23959   unsigned int jresult ;
23960   Dali::Pixel::Format arg1 ;
23961   unsigned int result;
23962
23963   arg1 = (Dali::Pixel::Format)jarg1;
23964   {
23965     try {
23966       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23967     } catch (std::out_of_range& e) {
23968       {
23969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23970       };
23971     } catch (std::exception& e) {
23972       {
23973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23974       };
23975     } catch (Dali::DaliException e) {
23976       {
23977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23978       };
23979     } catch (...) {
23980       {
23981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23982       };
23983     }
23984   }
23985
23986   jresult = result;
23987   return jresult;
23988 }
23989
23990
23991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23992   Dali::Pixel::Format arg1 ;
23993   int *arg2 = 0 ;
23994   int *arg3 = 0 ;
23995
23996   arg1 = (Dali::Pixel::Format)jarg1;
23997   arg2 = (int *)jarg2;
23998   if (!arg2) {
23999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
24000     return ;
24001   }
24002   arg3 = (int *)jarg3;
24003   if (!arg3) {
24004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
24005     return ;
24006   }
24007   {
24008     try {
24009       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
24010     } catch (std::out_of_range& e) {
24011       {
24012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24013       };
24014     } catch (std::exception& e) {
24015       {
24016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24017       };
24018     } catch (Dali::DaliException e) {
24019       {
24020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24021       };
24022     } catch (...) {
24023       {
24024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24025       };
24026     }
24027   }
24028
24029 }
24030
24031
24032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
24033   void * jresult ;
24034   unsigned char *arg1 = (unsigned char *) 0 ;
24035   unsigned int arg2 ;
24036   unsigned int arg3 ;
24037   unsigned int arg4 ;
24038   Dali::Pixel::Format arg5 ;
24039   Dali::PixelData::ReleaseFunction arg6 ;
24040   Dali::PixelData result;
24041
24042   arg1 = jarg1;
24043   arg2 = (unsigned int)jarg2;
24044   arg3 = (unsigned int)jarg3;
24045   arg4 = (unsigned int)jarg4;
24046   arg5 = (Dali::Pixel::Format)jarg5;
24047   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
24048   {
24049     try {
24050       auto pixelBuffer = new unsigned char[jarg2];
24051       memcpy( pixelBuffer, arg1, arg2);
24052       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
24053     } catch (std::out_of_range& e) {
24054       {
24055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24056       };
24057     } catch (std::exception& e) {
24058       {
24059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24060       };
24061     } catch (Dali::DaliException e) {
24062       {
24063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24064       };
24065     } catch (...) {
24066       {
24067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24068       };
24069     }
24070   }
24071
24072   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24073
24074
24075   return jresult;
24076 }
24077
24078
24079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24080   void * jresult ;
24081   Dali::PixelData *result = 0 ;
24082
24083   {
24084     try {
24085       result = (Dali::PixelData *)new Dali::PixelData();
24086     } catch (std::out_of_range& e) {
24087       {
24088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24089       };
24090     } catch (std::exception& e) {
24091       {
24092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24093       };
24094     } catch (Dali::DaliException e) {
24095       {
24096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24097       };
24098     } catch (...) {
24099       {
24100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24101       };
24102     }
24103   }
24104
24105   jresult = (void *)result;
24106   return jresult;
24107 }
24108
24109
24110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24111   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24112
24113   arg1 = (Dali::PixelData *)jarg1;
24114   {
24115     try {
24116       delete arg1;
24117     } catch (std::out_of_range& e) {
24118       {
24119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24120       };
24121     } catch (std::exception& e) {
24122       {
24123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24124       };
24125     } catch (Dali::DaliException e) {
24126       {
24127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24128       };
24129     } catch (...) {
24130       {
24131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24132       };
24133     }
24134   }
24135
24136 }
24137
24138
24139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24140   void * jresult ;
24141   Dali::PixelData *arg1 = 0 ;
24142   Dali::PixelData *result = 0 ;
24143
24144   arg1 = (Dali::PixelData *)jarg1;
24145   if (!arg1) {
24146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24147     return 0;
24148   }
24149   {
24150     try {
24151       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24152     } catch (std::out_of_range& e) {
24153       {
24154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24155       };
24156     } catch (std::exception& e) {
24157       {
24158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24159       };
24160     } catch (Dali::DaliException e) {
24161       {
24162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24163       };
24164     } catch (...) {
24165       {
24166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24167       };
24168     }
24169   }
24170
24171   jresult = (void *)result;
24172   return jresult;
24173 }
24174
24175
24176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24177   void * jresult ;
24178   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24179   Dali::PixelData *arg2 = 0 ;
24180   Dali::PixelData *result = 0 ;
24181
24182   arg1 = (Dali::PixelData *)jarg1;
24183   arg2 = (Dali::PixelData *)jarg2;
24184   if (!arg2) {
24185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24186     return 0;
24187   }
24188   {
24189     try {
24190       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24191     } catch (std::out_of_range& e) {
24192       {
24193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24194       };
24195     } catch (std::exception& e) {
24196       {
24197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24198       };
24199     } catch (Dali::DaliException e) {
24200       {
24201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24202       };
24203     } catch (...) {
24204       {
24205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24206       };
24207     }
24208   }
24209
24210   jresult = (void *)result;
24211   return jresult;
24212 }
24213
24214
24215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24216   unsigned int jresult ;
24217   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24218   unsigned int result;
24219
24220   arg1 = (Dali::PixelData *)jarg1;
24221   {
24222     try {
24223       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24224     } catch (std::out_of_range& e) {
24225       {
24226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24227       };
24228     } catch (std::exception& e) {
24229       {
24230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24231       };
24232     } catch (Dali::DaliException e) {
24233       {
24234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24235       };
24236     } catch (...) {
24237       {
24238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24239       };
24240     }
24241   }
24242
24243   jresult = result;
24244   return jresult;
24245 }
24246
24247
24248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24249   unsigned int jresult ;
24250   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24251   unsigned int result;
24252
24253   arg1 = (Dali::PixelData *)jarg1;
24254   {
24255     try {
24256       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24257     } catch (std::out_of_range& e) {
24258       {
24259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24260       };
24261     } catch (std::exception& e) {
24262       {
24263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24264       };
24265     } catch (Dali::DaliException e) {
24266       {
24267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24268       };
24269     } catch (...) {
24270       {
24271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24272       };
24273     }
24274   }
24275
24276   jresult = result;
24277   return jresult;
24278 }
24279
24280
24281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24282   int jresult ;
24283   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24284   Dali::Pixel::Format result;
24285
24286   arg1 = (Dali::PixelData *)jarg1;
24287   {
24288     try {
24289       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24290     } catch (std::out_of_range& e) {
24291       {
24292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24293       };
24294     } catch (std::exception& e) {
24295       {
24296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24297       };
24298     } catch (Dali::DaliException e) {
24299       {
24300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24301       };
24302     } catch (...) {
24303       {
24304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24305       };
24306     }
24307   }
24308
24309   jresult = (int)result;
24310   return jresult;
24311 }
24312
24313
24314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24315   unsigned int jresult ;
24316   unsigned int result;
24317
24318   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24319   jresult = result;
24320   return jresult;
24321 }
24322
24323
24324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24325   unsigned int jresult ;
24326   unsigned int result;
24327
24328   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24329   jresult = result;
24330   return jresult;
24331 }
24332
24333
24334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24335   unsigned int jresult ;
24336   unsigned int result;
24337
24338   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24339   jresult = result;
24340   return jresult;
24341 }
24342
24343
24344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24345   unsigned int jresult ;
24346   unsigned int result;
24347
24348   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24349   jresult = result;
24350   return jresult;
24351 }
24352
24353
24354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24355   unsigned int jresult ;
24356   unsigned int result;
24357
24358   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24359   jresult = result;
24360   return jresult;
24361 }
24362
24363
24364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24365   unsigned int jresult ;
24366   unsigned int result;
24367
24368   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24369   jresult = result;
24370   return jresult;
24371 }
24372
24373
24374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24375   void * jresult ;
24376   Dali::TextureType::Type arg1 ;
24377   Dali::Pixel::Format arg2 ;
24378   unsigned int arg3 ;
24379   unsigned int arg4 ;
24380   Dali::Texture result;
24381
24382   arg1 = (Dali::TextureType::Type)jarg1;
24383   arg2 = (Dali::Pixel::Format)jarg2;
24384   arg3 = (unsigned int)jarg3;
24385   arg4 = (unsigned int)jarg4;
24386   {
24387     try {
24388       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24389     } catch (std::out_of_range& e) {
24390       {
24391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24392       };
24393     } catch (std::exception& e) {
24394       {
24395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24396       };
24397     } catch (Dali::DaliException e) {
24398       {
24399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24400       };
24401     } catch (...) {
24402       {
24403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24404       };
24405     }
24406   }
24407
24408   jresult = new Dali::Texture((const Dali::Texture &)result);
24409   return jresult;
24410 }
24411
24412
24413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24414   void * jresult ;
24415   NativeImageInterface *arg1 = 0 ;
24416   Dali::Texture result;
24417
24418   arg1 = (NativeImageInterface *)jarg1;
24419   if (!arg1) {
24420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24421     return 0;
24422   }
24423   {
24424     try {
24425       result = Dali::Texture::New(*arg1);
24426     } catch (std::out_of_range& e) {
24427       {
24428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24429       };
24430     } catch (std::exception& e) {
24431       {
24432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24433       };
24434     } catch (Dali::DaliException e) {
24435       {
24436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24437       };
24438     } catch (...) {
24439       {
24440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24441       };
24442     }
24443   }
24444
24445   jresult = new Dali::Texture((const Dali::Texture &)result);
24446   return jresult;
24447 }
24448
24449
24450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24451   void * jresult ;
24452   Dali::Texture *result = 0 ;
24453
24454   {
24455     try {
24456       result = (Dali::Texture *)new Dali::Texture();
24457     } catch (std::out_of_range& e) {
24458       {
24459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24460       };
24461     } catch (std::exception& e) {
24462       {
24463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24464       };
24465     } catch (Dali::DaliException e) {
24466       {
24467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24468       };
24469     } catch (...) {
24470       {
24471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24472       };
24473     }
24474   }
24475
24476   jresult = (void *)result;
24477   return jresult;
24478 }
24479
24480
24481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24482   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24483
24484   arg1 = (Dali::Texture *)jarg1;
24485   {
24486     try {
24487       delete arg1;
24488     } catch (std::out_of_range& e) {
24489       {
24490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24491       };
24492     } catch (std::exception& e) {
24493       {
24494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24495       };
24496     } catch (Dali::DaliException e) {
24497       {
24498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24499       };
24500     } catch (...) {
24501       {
24502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24503       };
24504     }
24505   }
24506
24507 }
24508
24509
24510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24511   void * jresult ;
24512   Dali::Texture *arg1 = 0 ;
24513   Dali::Texture *result = 0 ;
24514
24515   arg1 = (Dali::Texture *)jarg1;
24516   if (!arg1) {
24517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24518     return 0;
24519   }
24520   {
24521     try {
24522       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24523     } catch (std::out_of_range& e) {
24524       {
24525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24526       };
24527     } catch (std::exception& e) {
24528       {
24529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24530       };
24531     } catch (Dali::DaliException e) {
24532       {
24533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24534       };
24535     } catch (...) {
24536       {
24537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24538       };
24539     }
24540   }
24541
24542   jresult = (void *)result;
24543   return jresult;
24544 }
24545
24546
24547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24548   void * jresult ;
24549   Dali::BaseHandle arg1 ;
24550   Dali::BaseHandle *argp1 ;
24551   Dali::Texture result;
24552
24553   argp1 = (Dali::BaseHandle *)jarg1;
24554   if (!argp1) {
24555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24556     return 0;
24557   }
24558   arg1 = *argp1;
24559   {
24560     try {
24561       result = Dali::Texture::DownCast(arg1);
24562     } catch (std::out_of_range& e) {
24563       {
24564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24565       };
24566     } catch (std::exception& e) {
24567       {
24568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24569       };
24570     } catch (Dali::DaliException e) {
24571       {
24572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24573       };
24574     } catch (...) {
24575       {
24576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24577       };
24578     }
24579   }
24580
24581   jresult = new Dali::Texture((const Dali::Texture &)result);
24582   return jresult;
24583 }
24584
24585
24586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24587   void * jresult ;
24588   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24589   Dali::Texture *arg2 = 0 ;
24590   Dali::Texture *result = 0 ;
24591
24592   arg1 = (Dali::Texture *)jarg1;
24593   arg2 = (Dali::Texture *)jarg2;
24594   if (!arg2) {
24595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24596     return 0;
24597   }
24598   {
24599     try {
24600       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24601     } catch (std::out_of_range& e) {
24602       {
24603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24604       };
24605     } catch (std::exception& e) {
24606       {
24607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24608       };
24609     } catch (Dali::DaliException e) {
24610       {
24611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24612       };
24613     } catch (...) {
24614       {
24615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24616       };
24617     }
24618   }
24619
24620   jresult = (void *)result;
24621   return jresult;
24622 }
24623
24624
24625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24626   unsigned int jresult ;
24627   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24628   Dali::PixelData arg2 ;
24629   Dali::PixelData *argp2 ;
24630   bool result;
24631
24632   arg1 = (Dali::Texture *)jarg1;
24633   argp2 = (Dali::PixelData *)jarg2;
24634   if (!argp2) {
24635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24636     return 0;
24637   }
24638   arg2 = *argp2;
24639   {
24640     try {
24641       result = (bool)(arg1)->Upload(arg2);
24642     } catch (std::out_of_range& e) {
24643       {
24644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24645       };
24646     } catch (std::exception& e) {
24647       {
24648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24649       };
24650     } catch (Dali::DaliException e) {
24651       {
24652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24653       };
24654     } catch (...) {
24655       {
24656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24657       };
24658     }
24659   }
24660
24661   jresult = result;
24662   return jresult;
24663 }
24664
24665
24666 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) {
24667   unsigned int jresult ;
24668   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24669   Dali::PixelData arg2 ;
24670   unsigned int arg3 ;
24671   unsigned int arg4 ;
24672   unsigned int arg5 ;
24673   unsigned int arg6 ;
24674   unsigned int arg7 ;
24675   unsigned int arg8 ;
24676   Dali::PixelData *argp2 ;
24677   bool result;
24678
24679   arg1 = (Dali::Texture *)jarg1;
24680   argp2 = (Dali::PixelData *)jarg2;
24681   if (!argp2) {
24682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24683     return 0;
24684   }
24685   arg2 = *argp2;
24686   arg3 = (unsigned int)jarg3;
24687   arg4 = (unsigned int)jarg4;
24688   arg5 = (unsigned int)jarg5;
24689   arg6 = (unsigned int)jarg6;
24690   arg7 = (unsigned int)jarg7;
24691   arg8 = (unsigned int)jarg8;
24692   {
24693     try {
24694       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24695     } catch (std::out_of_range& e) {
24696       {
24697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24698       };
24699     } catch (std::exception& e) {
24700       {
24701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24702       };
24703     } catch (Dali::DaliException e) {
24704       {
24705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24706       };
24707     } catch (...) {
24708       {
24709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24710       };
24711     }
24712   }
24713
24714   jresult = result;
24715   return jresult;
24716 }
24717
24718
24719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24720   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24721
24722   arg1 = (Dali::Texture *)jarg1;
24723   {
24724     try {
24725       (arg1)->GenerateMipmaps();
24726     } catch (std::out_of_range& e) {
24727       {
24728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24729       };
24730     } catch (std::exception& e) {
24731       {
24732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24733       };
24734     } catch (Dali::DaliException e) {
24735       {
24736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24737       };
24738     } catch (...) {
24739       {
24740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24741       };
24742     }
24743   }
24744
24745 }
24746
24747
24748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24749   unsigned int jresult ;
24750   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24751   unsigned int result;
24752
24753   arg1 = (Dali::Texture *)jarg1;
24754   {
24755     try {
24756       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24757     } catch (std::out_of_range& e) {
24758       {
24759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24760       };
24761     } catch (std::exception& e) {
24762       {
24763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24764       };
24765     } catch (Dali::DaliException e) {
24766       {
24767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24768       };
24769     } catch (...) {
24770       {
24771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24772       };
24773     }
24774   }
24775
24776   jresult = result;
24777   return jresult;
24778 }
24779
24780
24781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24782   unsigned int jresult ;
24783   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24784   unsigned int result;
24785
24786   arg1 = (Dali::Texture *)jarg1;
24787   {
24788     try {
24789       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24790     } catch (std::out_of_range& e) {
24791       {
24792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24793       };
24794     } catch (std::exception& e) {
24795       {
24796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24797       };
24798     } catch (Dali::DaliException e) {
24799       {
24800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24801       };
24802     } catch (...) {
24803       {
24804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24805       };
24806     }
24807   }
24808
24809   jresult = result;
24810   return jresult;
24811 }
24812
24813
24814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24815   void * jresult ;
24816   Dali::Sampler result;
24817
24818   {
24819     try {
24820       result = Dali::Sampler::New();
24821     } catch (std::out_of_range& e) {
24822       {
24823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24824       };
24825     } catch (std::exception& e) {
24826       {
24827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24828       };
24829     } catch (Dali::DaliException e) {
24830       {
24831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24832       };
24833     } catch (...) {
24834       {
24835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24836       };
24837     }
24838   }
24839
24840   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24841   return jresult;
24842 }
24843
24844
24845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24846   void * jresult ;
24847   Dali::Sampler *result = 0 ;
24848
24849   {
24850     try {
24851       result = (Dali::Sampler *)new Dali::Sampler();
24852     } catch (std::out_of_range& e) {
24853       {
24854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24855       };
24856     } catch (std::exception& e) {
24857       {
24858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24859       };
24860     } catch (Dali::DaliException e) {
24861       {
24862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24863       };
24864     } catch (...) {
24865       {
24866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24867       };
24868     }
24869   }
24870
24871   jresult = (void *)result;
24872   return jresult;
24873 }
24874
24875
24876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24877   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24878
24879   arg1 = (Dali::Sampler *)jarg1;
24880   {
24881     try {
24882       delete arg1;
24883     } catch (std::out_of_range& e) {
24884       {
24885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24886       };
24887     } catch (std::exception& e) {
24888       {
24889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24890       };
24891     } catch (Dali::DaliException e) {
24892       {
24893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24894       };
24895     } catch (...) {
24896       {
24897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24898       };
24899     }
24900   }
24901
24902 }
24903
24904
24905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24906   void * jresult ;
24907   Dali::Sampler *arg1 = 0 ;
24908   Dali::Sampler *result = 0 ;
24909
24910   arg1 = (Dali::Sampler *)jarg1;
24911   if (!arg1) {
24912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24913     return 0;
24914   }
24915   {
24916     try {
24917       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24918     } catch (std::out_of_range& e) {
24919       {
24920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24921       };
24922     } catch (std::exception& e) {
24923       {
24924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24925       };
24926     } catch (Dali::DaliException e) {
24927       {
24928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24929       };
24930     } catch (...) {
24931       {
24932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24933       };
24934     }
24935   }
24936
24937   jresult = (void *)result;
24938   return jresult;
24939 }
24940
24941
24942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24943   void * jresult ;
24944   Dali::BaseHandle arg1 ;
24945   Dali::BaseHandle *argp1 ;
24946   Dali::Sampler result;
24947
24948   argp1 = (Dali::BaseHandle *)jarg1;
24949   if (!argp1) {
24950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24951     return 0;
24952   }
24953   arg1 = *argp1;
24954   {
24955     try {
24956       result = Dali::Sampler::DownCast(arg1);
24957     } catch (std::out_of_range& e) {
24958       {
24959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24960       };
24961     } catch (std::exception& e) {
24962       {
24963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24964       };
24965     } catch (Dali::DaliException e) {
24966       {
24967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24968       };
24969     } catch (...) {
24970       {
24971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24972       };
24973     }
24974   }
24975
24976   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24977   return jresult;
24978 }
24979
24980
24981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24982   void * jresult ;
24983   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24984   Dali::Sampler *arg2 = 0 ;
24985   Dali::Sampler *result = 0 ;
24986
24987   arg1 = (Dali::Sampler *)jarg1;
24988   arg2 = (Dali::Sampler *)jarg2;
24989   if (!arg2) {
24990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24991     return 0;
24992   }
24993   {
24994     try {
24995       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24996     } catch (std::out_of_range& e) {
24997       {
24998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24999       };
25000     } catch (std::exception& e) {
25001       {
25002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25003       };
25004     } catch (Dali::DaliException e) {
25005       {
25006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25007       };
25008     } catch (...) {
25009       {
25010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25011       };
25012     }
25013   }
25014
25015   jresult = (void *)result;
25016   return jresult;
25017 }
25018
25019
25020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
25021   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25022   Dali::FilterMode::Type arg2 ;
25023   Dali::FilterMode::Type arg3 ;
25024
25025   arg1 = (Dali::Sampler *)jarg1;
25026   arg2 = (Dali::FilterMode::Type)jarg2;
25027   arg3 = (Dali::FilterMode::Type)jarg3;
25028   {
25029     try {
25030       (arg1)->SetFilterMode(arg2,arg3);
25031     } catch (std::out_of_range& e) {
25032       {
25033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25034       };
25035     } catch (std::exception& e) {
25036       {
25037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25038       };
25039     } catch (Dali::DaliException e) {
25040       {
25041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25042       };
25043     } catch (...) {
25044       {
25045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25046       };
25047     }
25048   }
25049
25050 }
25051
25052
25053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
25054   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25055   Dali::WrapMode::Type arg2 ;
25056   Dali::WrapMode::Type arg3 ;
25057
25058   arg1 = (Dali::Sampler *)jarg1;
25059   arg2 = (Dali::WrapMode::Type)jarg2;
25060   arg3 = (Dali::WrapMode::Type)jarg3;
25061   {
25062     try {
25063       (arg1)->SetWrapMode(arg2,arg3);
25064     } catch (std::out_of_range& e) {
25065       {
25066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25067       };
25068     } catch (std::exception& e) {
25069       {
25070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25071       };
25072     } catch (Dali::DaliException e) {
25073       {
25074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25075       };
25076     } catch (...) {
25077       {
25078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25079       };
25080     }
25081   }
25082
25083 }
25084
25085
25086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25087   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25088   Dali::WrapMode::Type arg2 ;
25089   Dali::WrapMode::Type arg3 ;
25090   Dali::WrapMode::Type arg4 ;
25091
25092   arg1 = (Dali::Sampler *)jarg1;
25093   arg2 = (Dali::WrapMode::Type)jarg2;
25094   arg3 = (Dali::WrapMode::Type)jarg3;
25095   arg4 = (Dali::WrapMode::Type)jarg4;
25096   {
25097     try {
25098       (arg1)->SetWrapMode(arg2,arg3,arg4);
25099     } catch (std::out_of_range& e) {
25100       {
25101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25102       };
25103     } catch (std::exception& e) {
25104       {
25105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25106       };
25107     } catch (Dali::DaliException e) {
25108       {
25109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25110       };
25111     } catch (...) {
25112       {
25113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25114       };
25115     }
25116   }
25117
25118 }
25119
25120
25121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25122   void * jresult ;
25123   Dali::TextureSet result;
25124
25125   {
25126     try {
25127       result = Dali::TextureSet::New();
25128     } catch (std::out_of_range& e) {
25129       {
25130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25131       };
25132     } catch (std::exception& e) {
25133       {
25134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25135       };
25136     } catch (Dali::DaliException e) {
25137       {
25138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25139       };
25140     } catch (...) {
25141       {
25142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25143       };
25144     }
25145   }
25146
25147   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25148   return jresult;
25149 }
25150
25151
25152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25153   void * jresult ;
25154   Dali::TextureSet *result = 0 ;
25155
25156   {
25157     try {
25158       result = (Dali::TextureSet *)new Dali::TextureSet();
25159     } catch (std::out_of_range& e) {
25160       {
25161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25162       };
25163     } catch (std::exception& e) {
25164       {
25165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25166       };
25167     } catch (Dali::DaliException e) {
25168       {
25169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25170       };
25171     } catch (...) {
25172       {
25173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25174       };
25175     }
25176   }
25177
25178   jresult = (void *)result;
25179   return jresult;
25180 }
25181
25182
25183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25184   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25185
25186   arg1 = (Dali::TextureSet *)jarg1;
25187   {
25188     try {
25189       delete arg1;
25190     } catch (std::out_of_range& e) {
25191       {
25192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25193       };
25194     } catch (std::exception& e) {
25195       {
25196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25197       };
25198     } catch (Dali::DaliException e) {
25199       {
25200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25201       };
25202     } catch (...) {
25203       {
25204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25205       };
25206     }
25207   }
25208
25209 }
25210
25211
25212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25213   void * jresult ;
25214   Dali::TextureSet *arg1 = 0 ;
25215   Dali::TextureSet *result = 0 ;
25216
25217   arg1 = (Dali::TextureSet *)jarg1;
25218   if (!arg1) {
25219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25220     return 0;
25221   }
25222   {
25223     try {
25224       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25225     } catch (std::out_of_range& e) {
25226       {
25227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25228       };
25229     } catch (std::exception& e) {
25230       {
25231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25232       };
25233     } catch (Dali::DaliException e) {
25234       {
25235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25236       };
25237     } catch (...) {
25238       {
25239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25240       };
25241     }
25242   }
25243
25244   jresult = (void *)result;
25245   return jresult;
25246 }
25247
25248
25249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25250   void * jresult ;
25251   Dali::BaseHandle arg1 ;
25252   Dali::BaseHandle *argp1 ;
25253   Dali::TextureSet result;
25254
25255   argp1 = (Dali::BaseHandle *)jarg1;
25256   if (!argp1) {
25257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25258     return 0;
25259   }
25260   arg1 = *argp1;
25261   {
25262     try {
25263       result = Dali::TextureSet::DownCast(arg1);
25264     } catch (std::out_of_range& e) {
25265       {
25266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25267       };
25268     } catch (std::exception& e) {
25269       {
25270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25271       };
25272     } catch (Dali::DaliException e) {
25273       {
25274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25275       };
25276     } catch (...) {
25277       {
25278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25279       };
25280     }
25281   }
25282
25283   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25284   return jresult;
25285 }
25286
25287
25288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25289   void * jresult ;
25290   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25291   Dali::TextureSet *arg2 = 0 ;
25292   Dali::TextureSet *result = 0 ;
25293
25294   arg1 = (Dali::TextureSet *)jarg1;
25295   arg2 = (Dali::TextureSet *)jarg2;
25296   if (!arg2) {
25297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25298     return 0;
25299   }
25300   {
25301     try {
25302       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25303     } catch (std::out_of_range& e) {
25304       {
25305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25306       };
25307     } catch (std::exception& e) {
25308       {
25309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25310       };
25311     } catch (Dali::DaliException e) {
25312       {
25313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25314       };
25315     } catch (...) {
25316       {
25317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25318       };
25319     }
25320   }
25321
25322   jresult = (void *)result;
25323   return jresult;
25324 }
25325
25326
25327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25328   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25329   size_t arg2 ;
25330   Dali::Texture arg3 ;
25331   Dali::Texture *argp3 ;
25332
25333   arg1 = (Dali::TextureSet *)jarg1;
25334   arg2 = (size_t)jarg2;
25335   argp3 = (Dali::Texture *)jarg3;
25336   if (!argp3) {
25337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25338     return ;
25339   }
25340   arg3 = *argp3;
25341   {
25342     try {
25343       (arg1)->SetTexture(arg2,arg3);
25344     } catch (std::out_of_range& e) {
25345       {
25346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25347       };
25348     } catch (std::exception& e) {
25349       {
25350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25351       };
25352     } catch (Dali::DaliException e) {
25353       {
25354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25355       };
25356     } catch (...) {
25357       {
25358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25359       };
25360     }
25361   }
25362
25363 }
25364
25365
25366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25367   void * jresult ;
25368   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25369   size_t arg2 ;
25370   Dali::Texture result;
25371
25372   arg1 = (Dali::TextureSet *)jarg1;
25373   arg2 = (size_t)jarg2;
25374   {
25375     try {
25376       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25377     } catch (std::out_of_range& e) {
25378       {
25379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25380       };
25381     } catch (std::exception& e) {
25382       {
25383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25384       };
25385     } catch (Dali::DaliException e) {
25386       {
25387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25388       };
25389     } catch (...) {
25390       {
25391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25392       };
25393     }
25394   }
25395
25396   jresult = new Dali::Texture((const Dali::Texture &)result);
25397   return jresult;
25398 }
25399
25400
25401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25402   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25403   size_t arg2 ;
25404   Dali::Sampler arg3 ;
25405   Dali::Sampler *argp3 ;
25406
25407   arg1 = (Dali::TextureSet *)jarg1;
25408   arg2 = (size_t)jarg2;
25409   argp3 = (Dali::Sampler *)jarg3;
25410   if (!argp3) {
25411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25412     return ;
25413   }
25414   arg3 = *argp3;
25415   {
25416     try {
25417       (arg1)->SetSampler(arg2,arg3);
25418     } catch (std::out_of_range& e) {
25419       {
25420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25421       };
25422     } catch (std::exception& e) {
25423       {
25424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25425       };
25426     } catch (Dali::DaliException e) {
25427       {
25428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25429       };
25430     } catch (...) {
25431       {
25432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25433       };
25434     }
25435   }
25436
25437 }
25438
25439
25440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25441   void * jresult ;
25442   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25443   size_t arg2 ;
25444   Dali::Sampler result;
25445
25446   arg1 = (Dali::TextureSet *)jarg1;
25447   arg2 = (size_t)jarg2;
25448   {
25449     try {
25450       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25451     } catch (std::out_of_range& e) {
25452       {
25453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25454       };
25455     } catch (std::exception& e) {
25456       {
25457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25458       };
25459     } catch (Dali::DaliException e) {
25460       {
25461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25462       };
25463     } catch (...) {
25464       {
25465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25466       };
25467     }
25468   }
25469
25470   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25471   return jresult;
25472 }
25473
25474
25475 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25476   unsigned long jresult ;
25477   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25478   size_t result;
25479
25480   arg1 = (Dali::TextureSet *)jarg1;
25481   {
25482     try {
25483       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25484     } catch (std::out_of_range& e) {
25485       {
25486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25487       };
25488     } catch (std::exception& e) {
25489       {
25490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25491       };
25492     } catch (Dali::DaliException e) {
25493       {
25494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25495       };
25496     } catch (...) {
25497       {
25498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25499       };
25500     }
25501   }
25502
25503   jresult = (unsigned long)result;
25504   return jresult;
25505 }
25506
25507
25508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25509   void * jresult ;
25510   Dali::Property::Map *arg1 = 0 ;
25511   Dali::PropertyBuffer result;
25512
25513   arg1 = (Dali::Property::Map *)jarg1;
25514   if (!arg1) {
25515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25516     return 0;
25517   }
25518   {
25519     try {
25520       result = Dali::PropertyBuffer::New(*arg1);
25521     } catch (std::out_of_range& e) {
25522       {
25523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25524       };
25525     } catch (std::exception& e) {
25526       {
25527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25528       };
25529     } catch (Dali::DaliException e) {
25530       {
25531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25532       };
25533     } catch (...) {
25534       {
25535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25536       };
25537     }
25538   }
25539
25540   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25541   return jresult;
25542 }
25543
25544
25545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25546   void * jresult ;
25547   Dali::PropertyBuffer *result = 0 ;
25548
25549   {
25550     try {
25551       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25552     } catch (std::out_of_range& e) {
25553       {
25554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25555       };
25556     } catch (std::exception& e) {
25557       {
25558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25559       };
25560     } catch (Dali::DaliException e) {
25561       {
25562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25563       };
25564     } catch (...) {
25565       {
25566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25567       };
25568     }
25569   }
25570
25571   jresult = (void *)result;
25572   return jresult;
25573 }
25574
25575
25576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25577   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25578
25579   arg1 = (Dali::PropertyBuffer *)jarg1;
25580   {
25581     try {
25582       delete arg1;
25583     } catch (std::out_of_range& e) {
25584       {
25585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25586       };
25587     } catch (std::exception& e) {
25588       {
25589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25590       };
25591     } catch (Dali::DaliException e) {
25592       {
25593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25594       };
25595     } catch (...) {
25596       {
25597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25598       };
25599     }
25600   }
25601
25602 }
25603
25604
25605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25606   void * jresult ;
25607   Dali::PropertyBuffer *arg1 = 0 ;
25608   Dali::PropertyBuffer *result = 0 ;
25609
25610   arg1 = (Dali::PropertyBuffer *)jarg1;
25611   if (!arg1) {
25612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25613     return 0;
25614   }
25615   {
25616     try {
25617       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25618     } catch (std::out_of_range& e) {
25619       {
25620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25621       };
25622     } catch (std::exception& e) {
25623       {
25624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25625       };
25626     } catch (Dali::DaliException e) {
25627       {
25628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25629       };
25630     } catch (...) {
25631       {
25632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25633       };
25634     }
25635   }
25636
25637   jresult = (void *)result;
25638   return jresult;
25639 }
25640
25641
25642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25643   void * jresult ;
25644   Dali::BaseHandle arg1 ;
25645   Dali::BaseHandle *argp1 ;
25646   Dali::PropertyBuffer result;
25647
25648   argp1 = (Dali::BaseHandle *)jarg1;
25649   if (!argp1) {
25650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25651     return 0;
25652   }
25653   arg1 = *argp1;
25654   {
25655     try {
25656       result = Dali::PropertyBuffer::DownCast(arg1);
25657     } catch (std::out_of_range& e) {
25658       {
25659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25660       };
25661     } catch (std::exception& e) {
25662       {
25663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25664       };
25665     } catch (Dali::DaliException e) {
25666       {
25667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25668       };
25669     } catch (...) {
25670       {
25671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25672       };
25673     }
25674   }
25675
25676   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25677   return jresult;
25678 }
25679
25680
25681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25682   void * jresult ;
25683   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25684   Dali::PropertyBuffer *arg2 = 0 ;
25685   Dali::PropertyBuffer *result = 0 ;
25686
25687   arg1 = (Dali::PropertyBuffer *)jarg1;
25688   arg2 = (Dali::PropertyBuffer *)jarg2;
25689   if (!arg2) {
25690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25691     return 0;
25692   }
25693   {
25694     try {
25695       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25696     } catch (std::out_of_range& e) {
25697       {
25698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25699       };
25700     } catch (std::exception& e) {
25701       {
25702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25703       };
25704     } catch (Dali::DaliException e) {
25705       {
25706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25707       };
25708     } catch (...) {
25709       {
25710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25711       };
25712     }
25713   }
25714
25715   jresult = (void *)result;
25716   return jresult;
25717 }
25718
25719
25720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25721   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25722   void *arg2 = (void *) 0 ;
25723   std::size_t arg3 ;
25724
25725   arg1 = (Dali::PropertyBuffer *)jarg1;
25726   arg2 = jarg2;
25727   arg3 = (std::size_t)jarg3;
25728   {
25729     try {
25730       (arg1)->SetData((void const *)arg2,arg3);
25731     } catch (std::out_of_range& e) {
25732       {
25733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25734       };
25735     } catch (std::exception& e) {
25736       {
25737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25738       };
25739     } catch (Dali::DaliException e) {
25740       {
25741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25742       };
25743     } catch (...) {
25744       {
25745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25746       };
25747     }
25748   }
25749
25750 }
25751
25752
25753 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25754   unsigned long jresult ;
25755   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25756   std::size_t result;
25757
25758   arg1 = (Dali::PropertyBuffer *)jarg1;
25759   {
25760     try {
25761       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25762     } catch (std::out_of_range& e) {
25763       {
25764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25765       };
25766     } catch (std::exception& e) {
25767       {
25768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25769       };
25770     } catch (Dali::DaliException e) {
25771       {
25772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25773       };
25774     } catch (...) {
25775       {
25776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25777       };
25778     }
25779   }
25780
25781   jresult = (unsigned long)result;
25782   return jresult;
25783 }
25784
25785
25786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25787   void * jresult ;
25788   Dali::Geometry result;
25789
25790   {
25791     try {
25792       result = Dali::Geometry::New();
25793     } catch (std::out_of_range& e) {
25794       {
25795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25796       };
25797     } catch (std::exception& e) {
25798       {
25799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25800       };
25801     } catch (Dali::DaliException e) {
25802       {
25803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25804       };
25805     } catch (...) {
25806       {
25807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25808       };
25809     }
25810   }
25811
25812   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25813   return jresult;
25814 }
25815
25816
25817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25818   void * jresult ;
25819   Dali::Geometry *result = 0 ;
25820
25821   {
25822     try {
25823       result = (Dali::Geometry *)new Dali::Geometry();
25824     } catch (std::out_of_range& e) {
25825       {
25826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25827       };
25828     } catch (std::exception& e) {
25829       {
25830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25831       };
25832     } catch (Dali::DaliException e) {
25833       {
25834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25835       };
25836     } catch (...) {
25837       {
25838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25839       };
25840     }
25841   }
25842
25843   jresult = (void *)result;
25844   return jresult;
25845 }
25846
25847
25848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25849   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25850
25851   arg1 = (Dali::Geometry *)jarg1;
25852   {
25853     try {
25854       delete arg1;
25855     } catch (std::out_of_range& e) {
25856       {
25857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25858       };
25859     } catch (std::exception& e) {
25860       {
25861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25862       };
25863     } catch (Dali::DaliException e) {
25864       {
25865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25866       };
25867     } catch (...) {
25868       {
25869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25870       };
25871     }
25872   }
25873
25874 }
25875
25876
25877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25878   void * jresult ;
25879   Dali::Geometry *arg1 = 0 ;
25880   Dali::Geometry *result = 0 ;
25881
25882   arg1 = (Dali::Geometry *)jarg1;
25883   if (!arg1) {
25884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25885     return 0;
25886   }
25887   {
25888     try {
25889       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25890     } catch (std::out_of_range& e) {
25891       {
25892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25893       };
25894     } catch (std::exception& e) {
25895       {
25896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25897       };
25898     } catch (Dali::DaliException e) {
25899       {
25900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25901       };
25902     } catch (...) {
25903       {
25904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25905       };
25906     }
25907   }
25908
25909   jresult = (void *)result;
25910   return jresult;
25911 }
25912
25913
25914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25915   void * jresult ;
25916   Dali::BaseHandle arg1 ;
25917   Dali::BaseHandle *argp1 ;
25918   Dali::Geometry result;
25919
25920   argp1 = (Dali::BaseHandle *)jarg1;
25921   if (!argp1) {
25922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25923     return 0;
25924   }
25925   arg1 = *argp1;
25926   {
25927     try {
25928       result = Dali::Geometry::DownCast(arg1);
25929     } catch (std::out_of_range& e) {
25930       {
25931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25932       };
25933     } catch (std::exception& e) {
25934       {
25935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25936       };
25937     } catch (Dali::DaliException e) {
25938       {
25939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25940       };
25941     } catch (...) {
25942       {
25943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25944       };
25945     }
25946   }
25947
25948   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25949   return jresult;
25950 }
25951
25952
25953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25954   void * jresult ;
25955   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25956   Dali::Geometry *arg2 = 0 ;
25957   Dali::Geometry *result = 0 ;
25958
25959   arg1 = (Dali::Geometry *)jarg1;
25960   arg2 = (Dali::Geometry *)jarg2;
25961   if (!arg2) {
25962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25963     return 0;
25964   }
25965   {
25966     try {
25967       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25968     } catch (std::out_of_range& e) {
25969       {
25970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25971       };
25972     } catch (std::exception& e) {
25973       {
25974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25975       };
25976     } catch (Dali::DaliException e) {
25977       {
25978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25979       };
25980     } catch (...) {
25981       {
25982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25983       };
25984     }
25985   }
25986
25987   jresult = (void *)result;
25988   return jresult;
25989 }
25990
25991
25992 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25993   unsigned long jresult ;
25994   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25995   Dali::PropertyBuffer *arg2 = 0 ;
25996   std::size_t result;
25997
25998   arg1 = (Dali::Geometry *)jarg1;
25999   arg2 = (Dali::PropertyBuffer *)jarg2;
26000   if (!arg2) {
26001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
26002     return 0;
26003   }
26004   {
26005     try {
26006       result = (arg1)->AddVertexBuffer(*arg2);
26007     } catch (std::out_of_range& e) {
26008       {
26009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26010       };
26011     } catch (std::exception& e) {
26012       {
26013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26014       };
26015     } catch (Dali::DaliException e) {
26016       {
26017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26018       };
26019     } catch (...) {
26020       {
26021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26022       };
26023     }
26024   }
26025
26026   jresult = (unsigned long)result;
26027   return jresult;
26028 }
26029
26030
26031 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
26032   unsigned long jresult ;
26033   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26034   std::size_t result;
26035
26036   arg1 = (Dali::Geometry *)jarg1;
26037   {
26038     try {
26039       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
26040     } catch (std::out_of_range& e) {
26041       {
26042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26043       };
26044     } catch (std::exception& e) {
26045       {
26046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26047       };
26048     } catch (Dali::DaliException e) {
26049       {
26050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26051       };
26052     } catch (...) {
26053       {
26054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26055       };
26056     }
26057   }
26058
26059   jresult = (unsigned long)result;
26060   return jresult;
26061 }
26062
26063
26064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
26065   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26066   std::size_t arg2 ;
26067
26068   arg1 = (Dali::Geometry *)jarg1;
26069   arg2 = (std::size_t)jarg2;
26070   {
26071     try {
26072       (arg1)->RemoveVertexBuffer(arg2);
26073     } catch (std::out_of_range& e) {
26074       {
26075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26076       };
26077     } catch (std::exception& e) {
26078       {
26079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26080       };
26081     } catch (Dali::DaliException e) {
26082       {
26083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26084       };
26085     } catch (...) {
26086       {
26087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26088       };
26089     }
26090   }
26091
26092 }
26093
26094
26095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26096   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26097   unsigned short *arg2 = (unsigned short *) 0 ;
26098   size_t arg3 ;
26099
26100   arg1 = (Dali::Geometry *)jarg1;
26101   arg2 = jarg2;
26102   arg3 = (size_t)jarg3;
26103   {
26104     try {
26105       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26106     } catch (std::out_of_range& e) {
26107       {
26108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26109       };
26110     } catch (std::exception& e) {
26111       {
26112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26113       };
26114     } catch (Dali::DaliException e) {
26115       {
26116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26117       };
26118     } catch (...) {
26119       {
26120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26121       };
26122     }
26123   }
26124
26125
26126
26127 }
26128
26129
26130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26131   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26132   Dali::Geometry::Type arg2 ;
26133
26134   arg1 = (Dali::Geometry *)jarg1;
26135   arg2 = (Dali::Geometry::Type)jarg2;
26136   {
26137     try {
26138       (arg1)->SetType(arg2);
26139     } catch (std::out_of_range& e) {
26140       {
26141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26142       };
26143     } catch (std::exception& e) {
26144       {
26145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26146       };
26147     } catch (Dali::DaliException e) {
26148       {
26149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26150       };
26151     } catch (...) {
26152       {
26153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26154       };
26155     }
26156   }
26157
26158 }
26159
26160
26161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26162   int jresult ;
26163   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26164   Dali::Geometry::Type result;
26165
26166   arg1 = (Dali::Geometry *)jarg1;
26167   {
26168     try {
26169       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26170     } catch (std::out_of_range& e) {
26171       {
26172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26173       };
26174     } catch (std::exception& e) {
26175       {
26176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26177       };
26178     } catch (Dali::DaliException e) {
26179       {
26180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26181       };
26182     } catch (...) {
26183       {
26184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26185       };
26186     }
26187   }
26188
26189   jresult = (int)result;
26190   return jresult;
26191 }
26192
26193
26194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26195   void * jresult ;
26196   Dali::Shader::Hint *result = 0 ;
26197
26198   {
26199     try {
26200       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26201     } catch (std::out_of_range& e) {
26202       {
26203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26204       };
26205     } catch (std::exception& e) {
26206       {
26207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26208       };
26209     } catch (Dali::DaliException e) {
26210       {
26211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26212       };
26213     } catch (...) {
26214       {
26215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26216       };
26217     }
26218   }
26219
26220   jresult = (void *)result;
26221   return jresult;
26222 }
26223
26224
26225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26226   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26227
26228   arg1 = (Dali::Shader::Hint *)jarg1;
26229   {
26230     try {
26231       delete arg1;
26232     } catch (std::out_of_range& e) {
26233       {
26234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26235       };
26236     } catch (std::exception& e) {
26237       {
26238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26239       };
26240     } catch (Dali::DaliException e) {
26241       {
26242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26243       };
26244     } catch (...) {
26245       {
26246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26247       };
26248     }
26249   }
26250
26251 }
26252
26253
26254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26255   int jresult ;
26256   int result;
26257
26258   result = (int)Dali::Shader::Property::PROGRAM;
26259   jresult = (int)result;
26260   return jresult;
26261 }
26262
26263
26264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26265   void * jresult ;
26266   Dali::Shader::Property *result = 0 ;
26267
26268   {
26269     try {
26270       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26271     } catch (std::out_of_range& e) {
26272       {
26273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26274       };
26275     } catch (std::exception& e) {
26276       {
26277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26278       };
26279     } catch (Dali::DaliException e) {
26280       {
26281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26282       };
26283     } catch (...) {
26284       {
26285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26286       };
26287     }
26288   }
26289
26290   jresult = (void *)result;
26291   return jresult;
26292 }
26293
26294
26295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26296   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26297
26298   arg1 = (Dali::Shader::Property *)jarg1;
26299   {
26300     try {
26301       delete arg1;
26302     } catch (std::out_of_range& e) {
26303       {
26304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26305       };
26306     } catch (std::exception& e) {
26307       {
26308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26309       };
26310     } catch (Dali::DaliException e) {
26311       {
26312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26313       };
26314     } catch (...) {
26315       {
26316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26317       };
26318     }
26319   }
26320
26321 }
26322
26323
26324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26325   void * jresult ;
26326   std::string *arg1 = 0 ;
26327   std::string *arg2 = 0 ;
26328   Dali::Shader::Hint::Value arg3 ;
26329   Dali::Shader result;
26330
26331   if (!jarg1) {
26332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26333     return 0;
26334   }
26335   std::string arg1_str(jarg1);
26336   arg1 = &arg1_str;
26337   if (!jarg2) {
26338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26339     return 0;
26340   }
26341   std::string arg2_str(jarg2);
26342   arg2 = &arg2_str;
26343   arg3 = (Dali::Shader::Hint::Value)jarg3;
26344   {
26345     try {
26346       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26347     } catch (std::out_of_range& e) {
26348       {
26349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26350       };
26351     } catch (std::exception& e) {
26352       {
26353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26354       };
26355     } catch (Dali::DaliException e) {
26356       {
26357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26358       };
26359     } catch (...) {
26360       {
26361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26362       };
26363     }
26364   }
26365
26366   jresult = new Dali::Shader((const Dali::Shader &)result);
26367
26368   //argout typemap for const std::string&
26369
26370
26371   //argout typemap for const std::string&
26372
26373   return jresult;
26374 }
26375
26376
26377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26378   void * jresult ;
26379   std::string *arg1 = 0 ;
26380   std::string *arg2 = 0 ;
26381   Dali::Shader result;
26382
26383   if (!jarg1) {
26384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26385     return 0;
26386   }
26387   std::string arg1_str(jarg1);
26388   arg1 = &arg1_str;
26389   if (!jarg2) {
26390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26391     return 0;
26392   }
26393   std::string arg2_str(jarg2);
26394   arg2 = &arg2_str;
26395   {
26396     try {
26397       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26398     } catch (std::out_of_range& e) {
26399       {
26400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26401       };
26402     } catch (std::exception& e) {
26403       {
26404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26405       };
26406     } catch (Dali::DaliException e) {
26407       {
26408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26409       };
26410     } catch (...) {
26411       {
26412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26413       };
26414     }
26415   }
26416
26417   jresult = new Dali::Shader((const Dali::Shader &)result);
26418
26419   //argout typemap for const std::string&
26420
26421
26422   //argout typemap for const std::string&
26423
26424   return jresult;
26425 }
26426
26427
26428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26429   void * jresult ;
26430   Dali::Shader *result = 0 ;
26431
26432   {
26433     try {
26434       result = (Dali::Shader *)new Dali::Shader();
26435     } catch (std::out_of_range& e) {
26436       {
26437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26438       };
26439     } catch (std::exception& e) {
26440       {
26441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26442       };
26443     } catch (Dali::DaliException e) {
26444       {
26445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26446       };
26447     } catch (...) {
26448       {
26449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26450       };
26451     }
26452   }
26453
26454   jresult = (void *)result;
26455   return jresult;
26456 }
26457
26458
26459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26460   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26461
26462   arg1 = (Dali::Shader *)jarg1;
26463   {
26464     try {
26465       delete arg1;
26466     } catch (std::out_of_range& e) {
26467       {
26468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26469       };
26470     } catch (std::exception& e) {
26471       {
26472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26473       };
26474     } catch (Dali::DaliException e) {
26475       {
26476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26477       };
26478     } catch (...) {
26479       {
26480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26481       };
26482     }
26483   }
26484
26485 }
26486
26487
26488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26489   void * jresult ;
26490   Dali::Shader *arg1 = 0 ;
26491   Dali::Shader *result = 0 ;
26492
26493   arg1 = (Dali::Shader *)jarg1;
26494   if (!arg1) {
26495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26496     return 0;
26497   }
26498   {
26499     try {
26500       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26501     } catch (std::out_of_range& e) {
26502       {
26503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26504       };
26505     } catch (std::exception& e) {
26506       {
26507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26508       };
26509     } catch (Dali::DaliException e) {
26510       {
26511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26512       };
26513     } catch (...) {
26514       {
26515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26516       };
26517     }
26518   }
26519
26520   jresult = (void *)result;
26521   return jresult;
26522 }
26523
26524
26525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26526   void * jresult ;
26527   Dali::BaseHandle arg1 ;
26528   Dali::BaseHandle *argp1 ;
26529   Dali::Shader result;
26530
26531   argp1 = (Dali::BaseHandle *)jarg1;
26532   if (!argp1) {
26533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26534     return 0;
26535   }
26536   arg1 = *argp1;
26537   {
26538     try {
26539       result = Dali::Shader::DownCast(arg1);
26540     } catch (std::out_of_range& e) {
26541       {
26542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26543       };
26544     } catch (std::exception& e) {
26545       {
26546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26547       };
26548     } catch (Dali::DaliException e) {
26549       {
26550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26551       };
26552     } catch (...) {
26553       {
26554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26555       };
26556     }
26557   }
26558
26559   jresult = new Dali::Shader((const Dali::Shader &)result);
26560   return jresult;
26561 }
26562
26563
26564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26565   void * jresult ;
26566   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26567   Dali::Shader *arg2 = 0 ;
26568   Dali::Shader *result = 0 ;
26569
26570   arg1 = (Dali::Shader *)jarg1;
26571   arg2 = (Dali::Shader *)jarg2;
26572   if (!arg2) {
26573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26574     return 0;
26575   }
26576   {
26577     try {
26578       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26579     } catch (std::out_of_range& e) {
26580       {
26581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26582       };
26583     } catch (std::exception& e) {
26584       {
26585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26586       };
26587     } catch (Dali::DaliException e) {
26588       {
26589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26590       };
26591     } catch (...) {
26592       {
26593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26594       };
26595     }
26596   }
26597
26598   jresult = (void *)result;
26599   return jresult;
26600 }
26601
26602
26603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26604   int jresult ;
26605   int result;
26606
26607   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26608   jresult = (int)result;
26609   return jresult;
26610 }
26611
26612
26613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26614   int jresult ;
26615   int result;
26616
26617   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26618   jresult = (int)result;
26619   return jresult;
26620 }
26621
26622
26623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26624   int jresult ;
26625   int result;
26626
26627   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26628   jresult = (int)result;
26629   return jresult;
26630 }
26631
26632
26633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26634   int jresult ;
26635   int result;
26636
26637   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26638   jresult = (int)result;
26639   return jresult;
26640 }
26641
26642
26643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26644   int jresult ;
26645   int result;
26646
26647   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26648   jresult = (int)result;
26649   return jresult;
26650 }
26651
26652
26653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26654   int jresult ;
26655   int result;
26656
26657   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26658   jresult = (int)result;
26659   return jresult;
26660 }
26661
26662
26663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26664   int jresult ;
26665   int result;
26666
26667   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26668   jresult = (int)result;
26669   return jresult;
26670 }
26671
26672
26673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26674   int jresult ;
26675   int result;
26676
26677   result = (int)Dali::Renderer::Property::BLEND_MODE;
26678   jresult = (int)result;
26679   return jresult;
26680 }
26681
26682
26683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26684   int jresult ;
26685   int result;
26686
26687   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26688   jresult = (int)result;
26689   return jresult;
26690 }
26691
26692
26693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26694   int jresult ;
26695   int result;
26696
26697   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26698   jresult = (int)result;
26699   return jresult;
26700 }
26701
26702
26703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26704   int jresult ;
26705   int result;
26706
26707   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26708   jresult = (int)result;
26709   return jresult;
26710 }
26711
26712
26713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26714   int jresult ;
26715   int result;
26716
26717   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26718   jresult = (int)result;
26719   return jresult;
26720 }
26721
26722
26723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26724   int jresult ;
26725   int result;
26726
26727   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26728   jresult = (int)result;
26729   return jresult;
26730 }
26731
26732
26733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26734   int jresult ;
26735   int result;
26736
26737   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26738   jresult = (int)result;
26739   return jresult;
26740 }
26741
26742
26743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26744   int jresult ;
26745   int result;
26746
26747   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26748   jresult = (int)result;
26749   return jresult;
26750 }
26751
26752
26753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26754   int jresult ;
26755   int result;
26756
26757   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26758   jresult = (int)result;
26759   return jresult;
26760 }
26761
26762
26763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26764   int jresult ;
26765   int result;
26766
26767   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26768   jresult = (int)result;
26769   return jresult;
26770 }
26771
26772
26773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26774   int jresult ;
26775   int result;
26776
26777   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26778   jresult = (int)result;
26779   return jresult;
26780 }
26781
26782
26783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26784   int jresult ;
26785   int result;
26786
26787   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26788   jresult = (int)result;
26789   return jresult;
26790 }
26791
26792
26793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26794   int jresult ;
26795   int result;
26796
26797   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26798   jresult = (int)result;
26799   return jresult;
26800 }
26801
26802
26803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26804   int jresult ;
26805   int result;
26806
26807   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26808   jresult = (int)result;
26809   return jresult;
26810 }
26811
26812
26813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26814   int jresult ;
26815   int result;
26816
26817   result = (int)Dali::Renderer::Property::RENDER_MODE;
26818   jresult = (int)result;
26819   return jresult;
26820 }
26821
26822
26823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26824   int jresult ;
26825   int result;
26826
26827   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26828   jresult = (int)result;
26829   return jresult;
26830 }
26831
26832
26833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26834   int jresult ;
26835   int result;
26836
26837   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26838   jresult = (int)result;
26839   return jresult;
26840 }
26841
26842
26843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26844   int jresult ;
26845   int result;
26846
26847   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26848   jresult = (int)result;
26849   return jresult;
26850 }
26851
26852
26853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26854   int jresult ;
26855   int result;
26856
26857   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26858   jresult = (int)result;
26859   return jresult;
26860 }
26861
26862
26863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26864   int jresult ;
26865   int result;
26866
26867   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26868   jresult = (int)result;
26869   return jresult;
26870 }
26871
26872
26873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26874   int jresult ;
26875   int result;
26876
26877   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26878   jresult = (int)result;
26879   return jresult;
26880 }
26881
26882
26883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26884   int jresult ;
26885   int result;
26886
26887   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26888   jresult = (int)result;
26889   return jresult;
26890 }
26891
26892
26893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26894   void * jresult ;
26895   Dali::Renderer::Property *result = 0 ;
26896
26897   {
26898     try {
26899       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26900     } catch (std::out_of_range& e) {
26901       {
26902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26903       };
26904     } catch (std::exception& e) {
26905       {
26906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26907       };
26908     } catch (Dali::DaliException e) {
26909       {
26910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26911       };
26912     } catch (...) {
26913       {
26914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26915       };
26916     }
26917   }
26918
26919   jresult = (void *)result;
26920   return jresult;
26921 }
26922
26923
26924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26925   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26926
26927   arg1 = (Dali::Renderer::Property *)jarg1;
26928   {
26929     try {
26930       delete arg1;
26931     } catch (std::out_of_range& e) {
26932       {
26933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26934       };
26935     } catch (std::exception& e) {
26936       {
26937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26938       };
26939     } catch (Dali::DaliException e) {
26940       {
26941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26942       };
26943     } catch (...) {
26944       {
26945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26946       };
26947     }
26948   }
26949
26950 }
26951
26952
26953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26954   void * jresult ;
26955   Dali::Geometry *arg1 = 0 ;
26956   Dali::Shader *arg2 = 0 ;
26957   Dali::Renderer result;
26958
26959   arg1 = (Dali::Geometry *)jarg1;
26960   if (!arg1) {
26961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26962     return 0;
26963   }
26964   arg2 = (Dali::Shader *)jarg2;
26965   if (!arg2) {
26966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26967     return 0;
26968   }
26969   {
26970     try {
26971       result = Dali::Renderer::New(*arg1,*arg2);
26972     } catch (std::out_of_range& e) {
26973       {
26974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26975       };
26976     } catch (std::exception& e) {
26977       {
26978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26979       };
26980     } catch (Dali::DaliException e) {
26981       {
26982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26983       };
26984     } catch (...) {
26985       {
26986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26987       };
26988     }
26989   }
26990
26991   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26992   return jresult;
26993 }
26994
26995
26996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26997   void * jresult ;
26998   Dali::Renderer *result = 0 ;
26999
27000   {
27001     try {
27002       result = (Dali::Renderer *)new Dali::Renderer();
27003     } catch (std::out_of_range& e) {
27004       {
27005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27006       };
27007     } catch (std::exception& e) {
27008       {
27009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27010       };
27011     } catch (Dali::DaliException e) {
27012       {
27013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27014       };
27015     } catch (...) {
27016       {
27017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27018       };
27019     }
27020   }
27021
27022   jresult = (void *)result;
27023   return jresult;
27024 }
27025
27026
27027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
27028   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27029
27030   arg1 = (Dali::Renderer *)jarg1;
27031   {
27032     try {
27033       delete arg1;
27034     } catch (std::out_of_range& e) {
27035       {
27036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27037       };
27038     } catch (std::exception& e) {
27039       {
27040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27041       };
27042     } catch (Dali::DaliException e) {
27043       {
27044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27045       };
27046     } catch (...) {
27047       {
27048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27049       };
27050     }
27051   }
27052
27053 }
27054
27055
27056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
27057   void * jresult ;
27058   Dali::Renderer *arg1 = 0 ;
27059   Dali::Renderer *result = 0 ;
27060
27061   arg1 = (Dali::Renderer *)jarg1;
27062   if (!arg1) {
27063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27064     return 0;
27065   }
27066   {
27067     try {
27068       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27069     } catch (std::out_of_range& e) {
27070       {
27071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27072       };
27073     } catch (std::exception& e) {
27074       {
27075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27076       };
27077     } catch (Dali::DaliException e) {
27078       {
27079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27080       };
27081     } catch (...) {
27082       {
27083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27084       };
27085     }
27086   }
27087
27088   jresult = (void *)result;
27089   return jresult;
27090 }
27091
27092
27093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27094   void * jresult ;
27095   Dali::BaseHandle arg1 ;
27096   Dali::BaseHandle *argp1 ;
27097   Dali::Renderer result;
27098
27099   argp1 = (Dali::BaseHandle *)jarg1;
27100   if (!argp1) {
27101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27102     return 0;
27103   }
27104   arg1 = *argp1;
27105   {
27106     try {
27107       result = Dali::Renderer::DownCast(arg1);
27108     } catch (std::out_of_range& e) {
27109       {
27110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27111       };
27112     } catch (std::exception& e) {
27113       {
27114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27115       };
27116     } catch (Dali::DaliException e) {
27117       {
27118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27119       };
27120     } catch (...) {
27121       {
27122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27123       };
27124     }
27125   }
27126
27127   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27128   return jresult;
27129 }
27130
27131
27132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27133   void * jresult ;
27134   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27135   Dali::Renderer *arg2 = 0 ;
27136   Dali::Renderer *result = 0 ;
27137
27138   arg1 = (Dali::Renderer *)jarg1;
27139   arg2 = (Dali::Renderer *)jarg2;
27140   if (!arg2) {
27141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27142     return 0;
27143   }
27144   {
27145     try {
27146       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27147     } catch (std::out_of_range& e) {
27148       {
27149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27150       };
27151     } catch (std::exception& e) {
27152       {
27153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27154       };
27155     } catch (Dali::DaliException e) {
27156       {
27157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27158       };
27159     } catch (...) {
27160       {
27161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27162       };
27163     }
27164   }
27165
27166   jresult = (void *)result;
27167   return jresult;
27168 }
27169
27170
27171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27172   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27173   Dali::Geometry *arg2 = 0 ;
27174
27175   arg1 = (Dali::Renderer *)jarg1;
27176   arg2 = (Dali::Geometry *)jarg2;
27177   if (!arg2) {
27178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27179     return ;
27180   }
27181   {
27182     try {
27183       (arg1)->SetGeometry(*arg2);
27184     } catch (std::out_of_range& e) {
27185       {
27186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27187       };
27188     } catch (std::exception& e) {
27189       {
27190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27191       };
27192     } catch (Dali::DaliException e) {
27193       {
27194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27195       };
27196     } catch (...) {
27197       {
27198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27199       };
27200     }
27201   }
27202
27203 }
27204
27205
27206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27207   void * jresult ;
27208   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27209   Dali::Geometry result;
27210
27211   arg1 = (Dali::Renderer *)jarg1;
27212   {
27213     try {
27214       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27215     } catch (std::out_of_range& e) {
27216       {
27217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27218       };
27219     } catch (std::exception& e) {
27220       {
27221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27222       };
27223     } catch (Dali::DaliException e) {
27224       {
27225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27226       };
27227     } catch (...) {
27228       {
27229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27230       };
27231     }
27232   }
27233
27234   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27235   return jresult;
27236 }
27237
27238
27239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27240   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27241   int arg2 ;
27242   int arg3 ;
27243
27244   arg1 = (Dali::Renderer *)jarg1;
27245   arg2 = (int)jarg2;
27246   arg3 = (int)jarg3;
27247   {
27248     try {
27249       (arg1)->SetIndexRange(arg2,arg3);
27250     } catch (std::out_of_range& e) {
27251       {
27252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27253       };
27254     } catch (std::exception& e) {
27255       {
27256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27257       };
27258     } catch (Dali::DaliException e) {
27259       {
27260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27261       };
27262     } catch (...) {
27263       {
27264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27265       };
27266     }
27267   }
27268
27269 }
27270
27271
27272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27273   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27274   Dali::TextureSet *arg2 = 0 ;
27275
27276   arg1 = (Dali::Renderer *)jarg1;
27277   arg2 = (Dali::TextureSet *)jarg2;
27278   if (!arg2) {
27279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27280     return ;
27281   }
27282   {
27283     try {
27284       (arg1)->SetTextures(*arg2);
27285     } catch (std::out_of_range& e) {
27286       {
27287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27288       };
27289     } catch (std::exception& e) {
27290       {
27291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27292       };
27293     } catch (Dali::DaliException e) {
27294       {
27295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27296       };
27297     } catch (...) {
27298       {
27299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27300       };
27301     }
27302   }
27303
27304 }
27305
27306
27307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27308   void * jresult ;
27309   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27310   Dali::TextureSet result;
27311
27312   arg1 = (Dali::Renderer *)jarg1;
27313   {
27314     try {
27315       result = ((Dali::Renderer const *)arg1)->GetTextures();
27316     } catch (std::out_of_range& e) {
27317       {
27318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27319       };
27320     } catch (std::exception& e) {
27321       {
27322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27323       };
27324     } catch (Dali::DaliException e) {
27325       {
27326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27327       };
27328     } catch (...) {
27329       {
27330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27331       };
27332     }
27333   }
27334
27335   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27336   return jresult;
27337 }
27338
27339
27340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27341   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27342   Dali::Shader *arg2 = 0 ;
27343
27344   arg1 = (Dali::Renderer *)jarg1;
27345   arg2 = (Dali::Shader *)jarg2;
27346   if (!arg2) {
27347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27348     return ;
27349   }
27350   {
27351     try {
27352       (arg1)->SetShader(*arg2);
27353     } catch (std::out_of_range& e) {
27354       {
27355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27356       };
27357     } catch (std::exception& e) {
27358       {
27359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27360       };
27361     } catch (Dali::DaliException e) {
27362       {
27363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27364       };
27365     } catch (...) {
27366       {
27367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27368       };
27369     }
27370   }
27371
27372 }
27373
27374
27375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27376   void * jresult ;
27377   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27378   Dali::Shader result;
27379
27380   arg1 = (Dali::Renderer *)jarg1;
27381   {
27382     try {
27383       result = ((Dali::Renderer const *)arg1)->GetShader();
27384     } catch (std::out_of_range& e) {
27385       {
27386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27387       };
27388     } catch (std::exception& e) {
27389       {
27390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27391       };
27392     } catch (Dali::DaliException e) {
27393       {
27394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27395       };
27396     } catch (...) {
27397       {
27398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27399       };
27400     }
27401   }
27402
27403   jresult = new Dali::Shader((const Dali::Shader &)result);
27404   return jresult;
27405 }
27406
27407
27408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27409   void * jresult ;
27410   Dali::FrameBuffer::Attachment *result = 0 ;
27411
27412   {
27413     try {
27414       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27415     } catch (std::out_of_range& e) {
27416       {
27417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27418       };
27419     } catch (std::exception& e) {
27420       {
27421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27422       };
27423     } catch (Dali::DaliException e) {
27424       {
27425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27426       };
27427     } catch (...) {
27428       {
27429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27430       };
27431     }
27432   }
27433
27434   jresult = (void *)result;
27435   return jresult;
27436 }
27437
27438
27439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27440   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27441
27442   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27443   {
27444     try {
27445       delete arg1;
27446     } catch (std::out_of_range& e) {
27447       {
27448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27449       };
27450     } catch (std::exception& e) {
27451       {
27452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27453       };
27454     } catch (Dali::DaliException e) {
27455       {
27456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27457       };
27458     } catch (...) {
27459       {
27460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27461       };
27462     }
27463   }
27464
27465 }
27466
27467
27468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27469   void * jresult ;
27470   unsigned int arg1 ;
27471   unsigned int arg2 ;
27472   unsigned int arg3 ;
27473   Dali::FrameBuffer result;
27474
27475   arg1 = (unsigned int)jarg1;
27476   arg2 = (unsigned int)jarg2;
27477   arg3 = (unsigned int)jarg3;
27478   {
27479     try {
27480       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27481     } catch (std::out_of_range& e) {
27482       {
27483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27484       };
27485     } catch (std::exception& e) {
27486       {
27487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27488       };
27489     } catch (Dali::DaliException e) {
27490       {
27491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27492       };
27493     } catch (...) {
27494       {
27495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27496       };
27497     }
27498   }
27499
27500   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27501   return jresult;
27502 }
27503
27504
27505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27506   void * jresult ;
27507   Dali::FrameBuffer *result = 0 ;
27508
27509   {
27510     try {
27511       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27512     } catch (std::out_of_range& e) {
27513       {
27514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27515       };
27516     } catch (std::exception& e) {
27517       {
27518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27519       };
27520     } catch (Dali::DaliException e) {
27521       {
27522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27523       };
27524     } catch (...) {
27525       {
27526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27527       };
27528     }
27529   }
27530
27531   jresult = (void *)result;
27532   return jresult;
27533 }
27534
27535
27536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27537   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27538
27539   arg1 = (Dali::FrameBuffer *)jarg1;
27540   {
27541     try {
27542       delete arg1;
27543     } catch (std::out_of_range& e) {
27544       {
27545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27546       };
27547     } catch (std::exception& e) {
27548       {
27549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27550       };
27551     } catch (Dali::DaliException e) {
27552       {
27553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27554       };
27555     } catch (...) {
27556       {
27557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27558       };
27559     }
27560   }
27561
27562 }
27563
27564
27565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27566   void * jresult ;
27567   Dali::FrameBuffer *arg1 = 0 ;
27568   Dali::FrameBuffer *result = 0 ;
27569
27570   arg1 = (Dali::FrameBuffer *)jarg1;
27571   if (!arg1) {
27572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27573     return 0;
27574   }
27575   {
27576     try {
27577       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27578     } catch (std::out_of_range& e) {
27579       {
27580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27581       };
27582     } catch (std::exception& e) {
27583       {
27584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27585       };
27586     } catch (Dali::DaliException e) {
27587       {
27588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27589       };
27590     } catch (...) {
27591       {
27592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27593       };
27594     }
27595   }
27596
27597   jresult = (void *)result;
27598   return jresult;
27599 }
27600
27601
27602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27603   void * jresult ;
27604   Dali::BaseHandle arg1 ;
27605   Dali::BaseHandle *argp1 ;
27606   Dali::FrameBuffer result;
27607
27608   argp1 = (Dali::BaseHandle *)jarg1;
27609   if (!argp1) {
27610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27611     return 0;
27612   }
27613   arg1 = *argp1;
27614   {
27615     try {
27616       result = Dali::FrameBuffer::DownCast(arg1);
27617     } catch (std::out_of_range& e) {
27618       {
27619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27620       };
27621     } catch (std::exception& e) {
27622       {
27623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27624       };
27625     } catch (Dali::DaliException e) {
27626       {
27627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27628       };
27629     } catch (...) {
27630       {
27631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27632       };
27633     }
27634   }
27635
27636   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27637   return jresult;
27638 }
27639
27640
27641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27642   void * jresult ;
27643   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27644   Dali::FrameBuffer *arg2 = 0 ;
27645   Dali::FrameBuffer *result = 0 ;
27646
27647   arg1 = (Dali::FrameBuffer *)jarg1;
27648   arg2 = (Dali::FrameBuffer *)jarg2;
27649   if (!arg2) {
27650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27651     return 0;
27652   }
27653   {
27654     try {
27655       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27656     } catch (std::out_of_range& e) {
27657       {
27658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27659       };
27660     } catch (std::exception& e) {
27661       {
27662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27663       };
27664     } catch (Dali::DaliException e) {
27665       {
27666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27667       };
27668     } catch (...) {
27669       {
27670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27671       };
27672     }
27673   }
27674
27675   jresult = (void *)result;
27676   return jresult;
27677 }
27678
27679
27680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27681   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27682   Dali::Texture *arg2 = 0 ;
27683
27684   arg1 = (Dali::FrameBuffer *)jarg1;
27685   arg2 = (Dali::Texture *)jarg2;
27686   if (!arg2) {
27687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27688     return ;
27689   }
27690   {
27691     try {
27692       (arg1)->AttachColorTexture(*arg2);
27693     } catch (std::out_of_range& e) {
27694       {
27695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27696       };
27697     } catch (std::exception& e) {
27698       {
27699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27700       };
27701     } catch (Dali::DaliException e) {
27702       {
27703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27704       };
27705     } catch (...) {
27706       {
27707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27708       };
27709     }
27710   }
27711
27712 }
27713
27714
27715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27716   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27717   Dali::Texture *arg2 = 0 ;
27718   unsigned int arg3 ;
27719   unsigned int arg4 ;
27720
27721   arg1 = (Dali::FrameBuffer *)jarg1;
27722   arg2 = (Dali::Texture *)jarg2;
27723   if (!arg2) {
27724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27725     return ;
27726   }
27727   arg3 = (unsigned int)jarg3;
27728   arg4 = (unsigned int)jarg4;
27729   {
27730     try {
27731       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27732     } catch (std::out_of_range& e) {
27733       {
27734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27735       };
27736     } catch (std::exception& e) {
27737       {
27738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27739       };
27740     } catch (Dali::DaliException e) {
27741       {
27742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27743       };
27744     } catch (...) {
27745       {
27746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27747       };
27748     }
27749   }
27750
27751 }
27752
27753
27754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27755   void * jresult ;
27756   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27757   Dali::Texture result;
27758
27759   arg1 = (Dali::FrameBuffer *)jarg1;
27760   {
27761     try {
27762       result = (arg1)->GetColorTexture();
27763     } catch (std::out_of_range& e) {
27764       {
27765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27766       };
27767     } catch (std::exception& e) {
27768       {
27769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27770       };
27771     } catch (Dali::DaliException e) {
27772       {
27773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27774       };
27775     } catch (...) {
27776       {
27777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27778       };
27779     }
27780   }
27781
27782   jresult = new Dali::Texture((const Dali::Texture &)result);
27783   return jresult;
27784 }
27785
27786
27787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27788   void * jresult ;
27789   Dali::RenderTaskList *result = 0 ;
27790
27791   {
27792     try {
27793       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27794     } catch (std::out_of_range& e) {
27795       {
27796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27797       };
27798     } catch (std::exception& e) {
27799       {
27800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27801       };
27802     } catch (Dali::DaliException e) {
27803       {
27804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27805       };
27806     } catch (...) {
27807       {
27808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27809       };
27810     }
27811   }
27812
27813   jresult = (void *)result;
27814   return jresult;
27815 }
27816
27817
27818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27819   void * jresult ;
27820   Dali::BaseHandle arg1 ;
27821   Dali::BaseHandle *argp1 ;
27822   Dali::RenderTaskList result;
27823
27824   argp1 = (Dali::BaseHandle *)jarg1;
27825   if (!argp1) {
27826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27827     return 0;
27828   }
27829   arg1 = *argp1;
27830   {
27831     try {
27832       result = Dali::RenderTaskList::DownCast(arg1);
27833     } catch (std::out_of_range& e) {
27834       {
27835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27836       };
27837     } catch (std::exception& e) {
27838       {
27839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27840       };
27841     } catch (Dali::DaliException e) {
27842       {
27843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27844       };
27845     } catch (...) {
27846       {
27847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27848       };
27849     }
27850   }
27851
27852   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27853   return jresult;
27854 }
27855
27856
27857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27858   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27859
27860   arg1 = (Dali::RenderTaskList *)jarg1;
27861   {
27862     try {
27863       delete arg1;
27864     } catch (std::out_of_range& e) {
27865       {
27866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27867       };
27868     } catch (std::exception& e) {
27869       {
27870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27871       };
27872     } catch (Dali::DaliException e) {
27873       {
27874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27875       };
27876     } catch (...) {
27877       {
27878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27879       };
27880     }
27881   }
27882
27883 }
27884
27885
27886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27887   void * jresult ;
27888   Dali::RenderTaskList *arg1 = 0 ;
27889   Dali::RenderTaskList *result = 0 ;
27890
27891   arg1 = (Dali::RenderTaskList *)jarg1;
27892   if (!arg1) {
27893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27894     return 0;
27895   }
27896   {
27897     try {
27898       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27899     } catch (std::out_of_range& e) {
27900       {
27901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27902       };
27903     } catch (std::exception& e) {
27904       {
27905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27906       };
27907     } catch (Dali::DaliException e) {
27908       {
27909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27910       };
27911     } catch (...) {
27912       {
27913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27914       };
27915     }
27916   }
27917
27918   jresult = (void *)result;
27919   return jresult;
27920 }
27921
27922
27923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27924   void * jresult ;
27925   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27926   Dali::RenderTaskList *arg2 = 0 ;
27927   Dali::RenderTaskList *result = 0 ;
27928
27929   arg1 = (Dali::RenderTaskList *)jarg1;
27930   arg2 = (Dali::RenderTaskList *)jarg2;
27931   if (!arg2) {
27932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27933     return 0;
27934   }
27935   {
27936     try {
27937       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27938     } catch (std::out_of_range& e) {
27939       {
27940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27941       };
27942     } catch (std::exception& e) {
27943       {
27944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27945       };
27946     } catch (Dali::DaliException e) {
27947       {
27948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27949       };
27950     } catch (...) {
27951       {
27952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27953       };
27954     }
27955   }
27956
27957   jresult = (void *)result;
27958   return jresult;
27959 }
27960
27961
27962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27963   void * jresult ;
27964   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27965   Dali::RenderTask result;
27966
27967   arg1 = (Dali::RenderTaskList *)jarg1;
27968   {
27969     try {
27970       result = (arg1)->CreateTask();
27971     } catch (std::out_of_range& e) {
27972       {
27973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27974       };
27975     } catch (std::exception& e) {
27976       {
27977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27978       };
27979     } catch (Dali::DaliException e) {
27980       {
27981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27982       };
27983     } catch (...) {
27984       {
27985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27986       };
27987     }
27988   }
27989
27990   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27991   return jresult;
27992 }
27993
27994
27995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27996   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27997   Dali::RenderTask arg2 ;
27998   Dali::RenderTask *argp2 ;
27999
28000   arg1 = (Dali::RenderTaskList *)jarg1;
28001   argp2 = (Dali::RenderTask *)jarg2;
28002   if (!argp2) {
28003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
28004     return ;
28005   }
28006   arg2 = *argp2;
28007   {
28008     try {
28009       (arg1)->RemoveTask(arg2);
28010     } catch (std::out_of_range& e) {
28011       {
28012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28013       };
28014     } catch (std::exception& e) {
28015       {
28016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28017       };
28018     } catch (Dali::DaliException e) {
28019       {
28020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28021       };
28022     } catch (...) {
28023       {
28024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28025       };
28026     }
28027   }
28028
28029 }
28030
28031
28032 //// ===============================================end part 1 =================
28033
28034 //// ========================= part 2 ===============================
28035
28036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
28037   unsigned int jresult ;
28038   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28039   unsigned int result;
28040
28041   arg1 = (Dali::RenderTaskList *)jarg1;
28042   {
28043     try {
28044       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
28045     } catch (std::out_of_range& e) {
28046       {
28047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28048       };
28049     } catch (std::exception& e) {
28050       {
28051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28052       };
28053     } catch (Dali::DaliException e) {
28054       {
28055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28056       };
28057     } catch (...) {
28058       {
28059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28060       };
28061     }
28062   }
28063
28064   jresult = result;
28065   return jresult;
28066 }
28067
28068
28069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28070   void * jresult ;
28071   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28072   unsigned int arg2 ;
28073   Dali::RenderTask result;
28074
28075   arg1 = (Dali::RenderTaskList *)jarg1;
28076   arg2 = (unsigned int)jarg2;
28077   {
28078     try {
28079       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28080     } catch (std::out_of_range& e) {
28081       {
28082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28083       };
28084     } catch (std::exception& e) {
28085       {
28086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28087       };
28088     } catch (Dali::DaliException e) {
28089       {
28090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28091       };
28092     } catch (...) {
28093       {
28094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28095       };
28096     }
28097   }
28098
28099   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28100   return jresult;
28101 }
28102
28103
28104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28105   int jresult ;
28106   int result;
28107
28108   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28109   jresult = (int)result;
28110   return jresult;
28111 }
28112
28113
28114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28115   int jresult ;
28116   int result;
28117
28118   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28119   jresult = (int)result;
28120   return jresult;
28121 }
28122
28123
28124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28125   int jresult ;
28126   int result;
28127
28128   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28129   jresult = (int)result;
28130   return jresult;
28131 }
28132
28133
28134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28135   int jresult ;
28136   int result;
28137
28138   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28139   jresult = (int)result;
28140   return jresult;
28141 }
28142
28143
28144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28145   void * jresult ;
28146   Dali::RenderTask::Property *result = 0 ;
28147
28148   {
28149     try {
28150       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28151     } catch (std::out_of_range& e) {
28152       {
28153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28154       };
28155     } catch (std::exception& e) {
28156       {
28157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28158       };
28159     } catch (Dali::DaliException e) {
28160       {
28161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28162       };
28163     } catch (...) {
28164       {
28165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28166       };
28167     }
28168   }
28169
28170   jresult = (void *)result;
28171   return jresult;
28172 }
28173
28174
28175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28176   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28177
28178   arg1 = (Dali::RenderTask::Property *)jarg1;
28179   {
28180     try {
28181       delete arg1;
28182     } catch (std::out_of_range& e) {
28183       {
28184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28185       };
28186     } catch (std::exception& e) {
28187       {
28188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28189       };
28190     } catch (Dali::DaliException e) {
28191       {
28192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28193       };
28194     } catch (...) {
28195       {
28196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28197       };
28198     }
28199   }
28200
28201 }
28202
28203
28204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28205   void * jresult ;
28206   bool (*result)(Dali::Vector2 &) = 0 ;
28207
28208   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28209   jresult = (void *)result;
28210   return jresult;
28211 }
28212
28213
28214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28215   void * jresult ;
28216   bool (*result)(Dali::Vector2 &) = 0 ;
28217
28218   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28219   jresult = (void *)result;
28220   return jresult;
28221 }
28222
28223
28224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28225   unsigned int jresult ;
28226   bool result;
28227
28228   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28229   jresult = result;
28230   return jresult;
28231 }
28232
28233
28234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28235   unsigned int jresult ;
28236   bool result;
28237
28238   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28239   jresult = result;
28240   return jresult;
28241 }
28242
28243
28244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28245   void * jresult ;
28246   Dali::Vector4 *result = 0 ;
28247
28248   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28249   jresult = (void *)result;
28250   return jresult;
28251 }
28252
28253
28254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28255   unsigned int jresult ;
28256   bool result;
28257
28258   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28259   jresult = result;
28260   return jresult;
28261 }
28262
28263
28264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28265   unsigned int jresult ;
28266   bool result;
28267
28268   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28269   jresult = result;
28270   return jresult;
28271 }
28272
28273
28274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28275   unsigned int jresult ;
28276   unsigned int result;
28277
28278   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28279   jresult = result;
28280   return jresult;
28281 }
28282
28283
28284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28285   void * jresult ;
28286   Dali::RenderTask *result = 0 ;
28287
28288   {
28289     try {
28290       result = (Dali::RenderTask *)new Dali::RenderTask();
28291     } catch (std::out_of_range& e) {
28292       {
28293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28294       };
28295     } catch (std::exception& e) {
28296       {
28297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28298       };
28299     } catch (Dali::DaliException e) {
28300       {
28301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28302       };
28303     } catch (...) {
28304       {
28305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28306       };
28307     }
28308   }
28309
28310   jresult = (void *)result;
28311   return jresult;
28312 }
28313
28314
28315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28316   void * jresult ;
28317   Dali::BaseHandle arg1 ;
28318   Dali::BaseHandle *argp1 ;
28319   Dali::RenderTask result;
28320
28321   argp1 = (Dali::BaseHandle *)jarg1;
28322   if (!argp1) {
28323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28324     return 0;
28325   }
28326   arg1 = *argp1;
28327   {
28328     try {
28329       result = Dali::RenderTask::DownCast(arg1);
28330     } catch (std::out_of_range& e) {
28331       {
28332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28333       };
28334     } catch (std::exception& e) {
28335       {
28336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28337       };
28338     } catch (Dali::DaliException e) {
28339       {
28340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28341       };
28342     } catch (...) {
28343       {
28344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28345       };
28346     }
28347   }
28348
28349   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28350   return jresult;
28351 }
28352
28353
28354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28355   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28356
28357   arg1 = (Dali::RenderTask *)jarg1;
28358   {
28359     try {
28360       delete arg1;
28361     } catch (std::out_of_range& e) {
28362       {
28363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28364       };
28365     } catch (std::exception& e) {
28366       {
28367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28368       };
28369     } catch (Dali::DaliException e) {
28370       {
28371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28372       };
28373     } catch (...) {
28374       {
28375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28376       };
28377     }
28378   }
28379
28380 }
28381
28382
28383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28384   void * jresult ;
28385   Dali::RenderTask *arg1 = 0 ;
28386   Dali::RenderTask *result = 0 ;
28387
28388   arg1 = (Dali::RenderTask *)jarg1;
28389   if (!arg1) {
28390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28391     return 0;
28392   }
28393   {
28394     try {
28395       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28396     } catch (std::out_of_range& e) {
28397       {
28398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28399       };
28400     } catch (std::exception& e) {
28401       {
28402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28403       };
28404     } catch (Dali::DaliException e) {
28405       {
28406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28407       };
28408     } catch (...) {
28409       {
28410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28411       };
28412     }
28413   }
28414
28415   jresult = (void *)result;
28416   return jresult;
28417 }
28418
28419
28420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28421   void * jresult ;
28422   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28423   Dali::RenderTask *arg2 = 0 ;
28424   Dali::RenderTask *result = 0 ;
28425
28426   arg1 = (Dali::RenderTask *)jarg1;
28427   arg2 = (Dali::RenderTask *)jarg2;
28428   if (!arg2) {
28429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28430     return 0;
28431   }
28432   {
28433     try {
28434       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28435     } catch (std::out_of_range& e) {
28436       {
28437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28438       };
28439     } catch (std::exception& e) {
28440       {
28441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28442       };
28443     } catch (Dali::DaliException e) {
28444       {
28445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28446       };
28447     } catch (...) {
28448       {
28449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28450       };
28451     }
28452   }
28453
28454   jresult = (void *)result;
28455   return jresult;
28456 }
28457
28458
28459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28460   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28461   Dali::Actor arg2 ;
28462   Dali::Actor *argp2 ;
28463
28464   arg1 = (Dali::RenderTask *)jarg1;
28465   argp2 = (Dali::Actor *)jarg2;
28466   if (!argp2) {
28467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28468     return ;
28469   }
28470   arg2 = *argp2;
28471   {
28472     try {
28473       (arg1)->SetSourceActor(arg2);
28474     } catch (std::out_of_range& e) {
28475       {
28476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28477       };
28478     } catch (std::exception& e) {
28479       {
28480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28481       };
28482     } catch (Dali::DaliException e) {
28483       {
28484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28485       };
28486     } catch (...) {
28487       {
28488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28489       };
28490     }
28491   }
28492
28493 }
28494
28495
28496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28497   void * jresult ;
28498   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28499   Dali::Actor result;
28500
28501   arg1 = (Dali::RenderTask *)jarg1;
28502   {
28503     try {
28504       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28505     } catch (std::out_of_range& e) {
28506       {
28507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28508       };
28509     } catch (std::exception& e) {
28510       {
28511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28512       };
28513     } catch (Dali::DaliException e) {
28514       {
28515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28516       };
28517     } catch (...) {
28518       {
28519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28520       };
28521     }
28522   }
28523
28524   jresult = new Dali::Actor((const Dali::Actor &)result);
28525   return jresult;
28526 }
28527
28528
28529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28530   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28531   bool arg2 ;
28532
28533   arg1 = (Dali::RenderTask *)jarg1;
28534   arg2 = jarg2 ? true : false;
28535   {
28536     try {
28537       (arg1)->SetExclusive(arg2);
28538     } catch (std::out_of_range& e) {
28539       {
28540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28541       };
28542     } catch (std::exception& e) {
28543       {
28544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28545       };
28546     } catch (Dali::DaliException e) {
28547       {
28548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28549       };
28550     } catch (...) {
28551       {
28552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28553       };
28554     }
28555   }
28556
28557 }
28558
28559
28560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28561   unsigned int jresult ;
28562   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28563   bool result;
28564
28565   arg1 = (Dali::RenderTask *)jarg1;
28566   {
28567     try {
28568       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28569     } catch (std::out_of_range& e) {
28570       {
28571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28572       };
28573     } catch (std::exception& e) {
28574       {
28575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28576       };
28577     } catch (Dali::DaliException e) {
28578       {
28579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28580       };
28581     } catch (...) {
28582       {
28583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28584       };
28585     }
28586   }
28587
28588   jresult = result;
28589   return jresult;
28590 }
28591
28592
28593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28594   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28595   bool arg2 ;
28596
28597   arg1 = (Dali::RenderTask *)jarg1;
28598   arg2 = jarg2 ? true : false;
28599   {
28600     try {
28601       (arg1)->SetInputEnabled(arg2);
28602     } catch (std::out_of_range& e) {
28603       {
28604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28605       };
28606     } catch (std::exception& e) {
28607       {
28608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28609       };
28610     } catch (Dali::DaliException e) {
28611       {
28612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28613       };
28614     } catch (...) {
28615       {
28616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28617       };
28618     }
28619   }
28620
28621 }
28622
28623
28624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28625   unsigned int jresult ;
28626   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28627   bool result;
28628
28629   arg1 = (Dali::RenderTask *)jarg1;
28630   {
28631     try {
28632       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28633     } catch (std::out_of_range& e) {
28634       {
28635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28636       };
28637     } catch (std::exception& e) {
28638       {
28639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28640       };
28641     } catch (Dali::DaliException e) {
28642       {
28643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28644       };
28645     } catch (...) {
28646       {
28647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28648       };
28649     }
28650   }
28651
28652   jresult = result;
28653   return jresult;
28654 }
28655
28656
28657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28658   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28659   Dali::CameraActor arg2 ;
28660   Dali::CameraActor *argp2 ;
28661
28662   arg1 = (Dali::RenderTask *)jarg1;
28663   argp2 = (Dali::CameraActor *)jarg2;
28664   if (!argp2) {
28665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28666     return ;
28667   }
28668   arg2 = *argp2;
28669   {
28670     try {
28671       (arg1)->SetCameraActor(arg2);
28672     } catch (std::out_of_range& e) {
28673       {
28674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28675       };
28676     } catch (std::exception& e) {
28677       {
28678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28679       };
28680     } catch (Dali::DaliException e) {
28681       {
28682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28683       };
28684     } catch (...) {
28685       {
28686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28687       };
28688     }
28689   }
28690
28691 }
28692
28693
28694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28695   void * jresult ;
28696   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28697   Dali::CameraActor result;
28698
28699   arg1 = (Dali::RenderTask *)jarg1;
28700   {
28701     try {
28702       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28703     } catch (std::out_of_range& e) {
28704       {
28705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28706       };
28707     } catch (std::exception& e) {
28708       {
28709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28710       };
28711     } catch (Dali::DaliException e) {
28712       {
28713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28714       };
28715     } catch (...) {
28716       {
28717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28718       };
28719     }
28720   }
28721
28722   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28723   return jresult;
28724 }
28725
28726
28727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28728   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28729   Dali::FrameBufferImage arg2 ;
28730   Dali::FrameBufferImage *argp2 ;
28731
28732   arg1 = (Dali::RenderTask *)jarg1;
28733   argp2 = (Dali::FrameBufferImage *)jarg2;
28734   if (!argp2) {
28735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28736     return ;
28737   }
28738   arg2 = *argp2;
28739   {
28740     try {
28741       (arg1)->SetTargetFrameBuffer(arg2);
28742     } catch (std::out_of_range& e) {
28743       {
28744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28745       };
28746     } catch (std::exception& e) {
28747       {
28748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28749       };
28750     } catch (Dali::DaliException e) {
28751       {
28752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28753       };
28754     } catch (...) {
28755       {
28756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28757       };
28758     }
28759   }
28760
28761 }
28762
28763
28764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28765   void * jresult ;
28766   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28767   Dali::FrameBufferImage result;
28768
28769   arg1 = (Dali::RenderTask *)jarg1;
28770   {
28771     try {
28772       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28773     } catch (std::out_of_range& e) {
28774       {
28775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28776       };
28777     } catch (std::exception& e) {
28778       {
28779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28780       };
28781     } catch (Dali::DaliException e) {
28782       {
28783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28784       };
28785     } catch (...) {
28786       {
28787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28788       };
28789     }
28790   }
28791
28792   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28793   return jresult;
28794 }
28795
28796
28797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28798   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28799   Dali::FrameBuffer arg2 ;
28800   Dali::FrameBuffer *argp2 ;
28801
28802   arg1 = (Dali::RenderTask *)jarg1;
28803   argp2 = (Dali::FrameBuffer *)jarg2;
28804   if (!argp2) {
28805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28806     return ;
28807   }
28808   arg2 = *argp2;
28809   {
28810     try {
28811       (arg1)->SetFrameBuffer(arg2);
28812     } catch (std::out_of_range& e) {
28813       {
28814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28815       };
28816     } catch (std::exception& e) {
28817       {
28818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28819       };
28820     } catch (Dali::DaliException e) {
28821       {
28822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28823       };
28824     } catch (...) {
28825       {
28826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28827       };
28828     }
28829   }
28830
28831 }
28832
28833
28834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28835   void * jresult ;
28836   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28837   Dali::FrameBuffer result;
28838
28839   arg1 = (Dali::RenderTask *)jarg1;
28840   {
28841     try {
28842       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28843     } catch (std::out_of_range& e) {
28844       {
28845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28846       };
28847     } catch (std::exception& e) {
28848       {
28849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28850       };
28851     } catch (Dali::DaliException e) {
28852       {
28853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28854       };
28855     } catch (...) {
28856       {
28857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28858       };
28859     }
28860   }
28861
28862   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28863   return jresult;
28864 }
28865
28866
28867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28868   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28869   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28870
28871   arg1 = (Dali::RenderTask *)jarg1;
28872   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28873   {
28874     try {
28875       (arg1)->SetScreenToFrameBufferFunction(arg2);
28876     } catch (std::out_of_range& e) {
28877       {
28878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28879       };
28880     } catch (std::exception& e) {
28881       {
28882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28883       };
28884     } catch (Dali::DaliException e) {
28885       {
28886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28887       };
28888     } catch (...) {
28889       {
28890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28891       };
28892     }
28893   }
28894
28895 }
28896
28897
28898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28899   void * jresult ;
28900   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28901   Dali::RenderTask::ScreenToFrameBufferFunction result;
28902
28903   arg1 = (Dali::RenderTask *)jarg1;
28904   {
28905     try {
28906       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28907     } catch (std::out_of_range& e) {
28908       {
28909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28910       };
28911     } catch (std::exception& e) {
28912       {
28913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28914       };
28915     } catch (Dali::DaliException e) {
28916       {
28917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28918       };
28919     } catch (...) {
28920       {
28921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28922       };
28923     }
28924   }
28925
28926   jresult = (void *)result;
28927   return jresult;
28928 }
28929
28930
28931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28932   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28933   Dali::Actor arg2 ;
28934   Dali::Actor *argp2 ;
28935
28936   arg1 = (Dali::RenderTask *)jarg1;
28937   argp2 = (Dali::Actor *)jarg2;
28938   if (!argp2) {
28939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28940     return ;
28941   }
28942   arg2 = *argp2;
28943   {
28944     try {
28945       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28946     } catch (std::out_of_range& e) {
28947       {
28948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28949       };
28950     } catch (std::exception& e) {
28951       {
28952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28953       };
28954     } catch (Dali::DaliException e) {
28955       {
28956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28957       };
28958     } catch (...) {
28959       {
28960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28961       };
28962     }
28963   }
28964
28965 }
28966
28967
28968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28969   void * jresult ;
28970   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28971   Dali::Actor result;
28972
28973   arg1 = (Dali::RenderTask *)jarg1;
28974   {
28975     try {
28976       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28977     } catch (std::out_of_range& e) {
28978       {
28979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28980       };
28981     } catch (std::exception& e) {
28982       {
28983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28984       };
28985     } catch (Dali::DaliException e) {
28986       {
28987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28988       };
28989     } catch (...) {
28990       {
28991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28992       };
28993     }
28994   }
28995
28996   jresult = new Dali::Actor((const Dali::Actor &)result);
28997   return jresult;
28998 }
28999
29000
29001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
29002   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29003   Dali::Vector2 arg2 ;
29004   Dali::Vector2 *argp2 ;
29005
29006   arg1 = (Dali::RenderTask *)jarg1;
29007   argp2 = (Dali::Vector2 *)jarg2;
29008   if (!argp2) {
29009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29010     return ;
29011   }
29012   arg2 = *argp2;
29013   {
29014     try {
29015       (arg1)->SetViewportPosition(arg2);
29016     } catch (std::out_of_range& e) {
29017       {
29018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29019       };
29020     } catch (std::exception& e) {
29021       {
29022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29023       };
29024     } catch (Dali::DaliException e) {
29025       {
29026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29027       };
29028     } catch (...) {
29029       {
29030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29031       };
29032     }
29033   }
29034
29035 }
29036
29037
29038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
29039   void * jresult ;
29040   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29041   Dali::Vector2 result;
29042
29043   arg1 = (Dali::RenderTask *)jarg1;
29044   {
29045     try {
29046       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
29047     } catch (std::out_of_range& e) {
29048       {
29049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29050       };
29051     } catch (std::exception& e) {
29052       {
29053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29054       };
29055     } catch (Dali::DaliException e) {
29056       {
29057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29058       };
29059     } catch (...) {
29060       {
29061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29062       };
29063     }
29064   }
29065
29066   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29067   return jresult;
29068 }
29069
29070
29071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29072   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29073   Dali::Vector2 arg2 ;
29074   Dali::Vector2 *argp2 ;
29075
29076   arg1 = (Dali::RenderTask *)jarg1;
29077   argp2 = (Dali::Vector2 *)jarg2;
29078   if (!argp2) {
29079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29080     return ;
29081   }
29082   arg2 = *argp2;
29083   {
29084     try {
29085       (arg1)->SetViewportSize(arg2);
29086     } catch (std::out_of_range& e) {
29087       {
29088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29089       };
29090     } catch (std::exception& e) {
29091       {
29092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29093       };
29094     } catch (Dali::DaliException e) {
29095       {
29096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29097       };
29098     } catch (...) {
29099       {
29100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29101       };
29102     }
29103   }
29104
29105 }
29106
29107
29108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29109   void * jresult ;
29110   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29111   Dali::Vector2 result;
29112
29113   arg1 = (Dali::RenderTask *)jarg1;
29114   {
29115     try {
29116       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29117     } catch (std::out_of_range& e) {
29118       {
29119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29120       };
29121     } catch (std::exception& e) {
29122       {
29123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29124       };
29125     } catch (Dali::DaliException e) {
29126       {
29127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29128       };
29129     } catch (...) {
29130       {
29131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29132       };
29133     }
29134   }
29135
29136   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29137   return jresult;
29138 }
29139
29140
29141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29142   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29143   Dali::Viewport arg2 ;
29144   Dali::Viewport *argp2 ;
29145
29146   arg1 = (Dali::RenderTask *)jarg1;
29147   argp2 = (Dali::Viewport *)jarg2;
29148   if (!argp2) {
29149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29150     return ;
29151   }
29152   arg2 = *argp2;
29153   {
29154     try {
29155       (arg1)->SetViewport(arg2);
29156     } catch (std::out_of_range& e) {
29157       {
29158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29159       };
29160     } catch (std::exception& e) {
29161       {
29162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29163       };
29164     } catch (Dali::DaliException e) {
29165       {
29166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29167       };
29168     } catch (...) {
29169       {
29170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29171       };
29172     }
29173   }
29174
29175 }
29176
29177
29178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29179   void * jresult ;
29180   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29181   Dali::Viewport result;
29182
29183   arg1 = (Dali::RenderTask *)jarg1;
29184   {
29185     try {
29186       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29187     } catch (std::out_of_range& e) {
29188       {
29189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29190       };
29191     } catch (std::exception& e) {
29192       {
29193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29194       };
29195     } catch (Dali::DaliException e) {
29196       {
29197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29198       };
29199     } catch (...) {
29200       {
29201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29202       };
29203     }
29204   }
29205
29206   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29207   return jresult;
29208 }
29209
29210
29211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29212   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29213   Dali::Vector4 *arg2 = 0 ;
29214
29215   arg1 = (Dali::RenderTask *)jarg1;
29216   arg2 = (Dali::Vector4 *)jarg2;
29217   if (!arg2) {
29218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29219     return ;
29220   }
29221   {
29222     try {
29223       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29224     } catch (std::out_of_range& e) {
29225       {
29226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29227       };
29228     } catch (std::exception& e) {
29229       {
29230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29231       };
29232     } catch (Dali::DaliException e) {
29233       {
29234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29235       };
29236     } catch (...) {
29237       {
29238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29239       };
29240     }
29241   }
29242
29243 }
29244
29245
29246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29247   void * jresult ;
29248   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29249   Dali::Vector4 result;
29250
29251   arg1 = (Dali::RenderTask *)jarg1;
29252   {
29253     try {
29254       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29255     } catch (std::out_of_range& e) {
29256       {
29257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29258       };
29259     } catch (std::exception& e) {
29260       {
29261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29262       };
29263     } catch (Dali::DaliException e) {
29264       {
29265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29266       };
29267     } catch (...) {
29268       {
29269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29270       };
29271     }
29272   }
29273
29274   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29275   return jresult;
29276 }
29277
29278
29279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29280   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29281   bool arg2 ;
29282
29283   arg1 = (Dali::RenderTask *)jarg1;
29284   arg2 = jarg2 ? true : false;
29285   {
29286     try {
29287       (arg1)->SetClearEnabled(arg2);
29288     } catch (std::out_of_range& e) {
29289       {
29290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29291       };
29292     } catch (std::exception& e) {
29293       {
29294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29295       };
29296     } catch (Dali::DaliException e) {
29297       {
29298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29299       };
29300     } catch (...) {
29301       {
29302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29303       };
29304     }
29305   }
29306
29307 }
29308
29309
29310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29311   unsigned int jresult ;
29312   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29313   bool result;
29314
29315   arg1 = (Dali::RenderTask *)jarg1;
29316   {
29317     try {
29318       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29319     } catch (std::out_of_range& e) {
29320       {
29321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29322       };
29323     } catch (std::exception& e) {
29324       {
29325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29326       };
29327     } catch (Dali::DaliException e) {
29328       {
29329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29330       };
29331     } catch (...) {
29332       {
29333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29334       };
29335     }
29336   }
29337
29338   jresult = result;
29339   return jresult;
29340 }
29341
29342
29343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29344   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29345   bool arg2 ;
29346
29347   arg1 = (Dali::RenderTask *)jarg1;
29348   arg2 = jarg2 ? true : false;
29349   {
29350     try {
29351       (arg1)->SetCullMode(arg2);
29352     } catch (std::out_of_range& e) {
29353       {
29354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29355       };
29356     } catch (std::exception& e) {
29357       {
29358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29359       };
29360     } catch (Dali::DaliException e) {
29361       {
29362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29363       };
29364     } catch (...) {
29365       {
29366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29367       };
29368     }
29369   }
29370
29371 }
29372
29373
29374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29375   unsigned int jresult ;
29376   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29377   bool result;
29378
29379   arg1 = (Dali::RenderTask *)jarg1;
29380   {
29381     try {
29382       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29383     } catch (std::out_of_range& e) {
29384       {
29385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29386       };
29387     } catch (std::exception& e) {
29388       {
29389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29390       };
29391     } catch (Dali::DaliException e) {
29392       {
29393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29394       };
29395     } catch (...) {
29396       {
29397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29398       };
29399     }
29400   }
29401
29402   jresult = result;
29403   return jresult;
29404 }
29405
29406
29407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29408   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29409   unsigned int arg2 ;
29410
29411   arg1 = (Dali::RenderTask *)jarg1;
29412   arg2 = (unsigned int)jarg2;
29413   {
29414     try {
29415       (arg1)->SetRefreshRate(arg2);
29416     } catch (std::out_of_range& e) {
29417       {
29418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29419       };
29420     } catch (std::exception& e) {
29421       {
29422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29423       };
29424     } catch (Dali::DaliException e) {
29425       {
29426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29427       };
29428     } catch (...) {
29429       {
29430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29431       };
29432     }
29433   }
29434
29435 }
29436
29437
29438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29439   unsigned int jresult ;
29440   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29441   unsigned int result;
29442
29443   arg1 = (Dali::RenderTask *)jarg1;
29444   {
29445     try {
29446       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29447     } catch (std::out_of_range& e) {
29448       {
29449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29450       };
29451     } catch (std::exception& e) {
29452       {
29453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29454       };
29455     } catch (Dali::DaliException e) {
29456       {
29457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29458       };
29459     } catch (...) {
29460       {
29461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29462       };
29463     }
29464   }
29465
29466   jresult = result;
29467   return jresult;
29468 }
29469
29470
29471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29472   unsigned int jresult ;
29473   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29474   Dali::Vector3 *arg2 = 0 ;
29475   float *arg3 = 0 ;
29476   float *arg4 = 0 ;
29477   bool result;
29478
29479   arg1 = (Dali::RenderTask *)jarg1;
29480   arg2 = (Dali::Vector3 *)jarg2;
29481   if (!arg2) {
29482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29483     return 0;
29484   }
29485   arg3 = (float *)jarg3;
29486   arg4 = (float *)jarg4;
29487   {
29488     try {
29489       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29490     } catch (std::out_of_range& e) {
29491       {
29492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29493       };
29494     } catch (std::exception& e) {
29495       {
29496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29497       };
29498     } catch (Dali::DaliException e) {
29499       {
29500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29501       };
29502     } catch (...) {
29503       {
29504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29505       };
29506     }
29507   }
29508
29509   jresult = result;
29510   return jresult;
29511 }
29512
29513
29514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29515   unsigned int jresult ;
29516   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29517   Dali::Actor arg2 ;
29518   float arg3 ;
29519   float arg4 ;
29520   float *arg5 = 0 ;
29521   float *arg6 = 0 ;
29522   Dali::Actor *argp2 ;
29523   bool result;
29524
29525   arg1 = (Dali::RenderTask *)jarg1;
29526   argp2 = (Dali::Actor *)jarg2;
29527   if (!argp2) {
29528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29529     return 0;
29530   }
29531   arg2 = *argp2;
29532   arg3 = (float)jarg3;
29533   arg4 = (float)jarg4;
29534   arg5 = (float *)jarg5;
29535   arg6 = (float *)jarg6;
29536   {
29537     try {
29538       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29539     } catch (std::out_of_range& e) {
29540       {
29541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29542       };
29543     } catch (std::exception& e) {
29544       {
29545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29546       };
29547     } catch (Dali::DaliException e) {
29548       {
29549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29550       };
29551     } catch (...) {
29552       {
29553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29554       };
29555     }
29556   }
29557
29558   jresult = result;
29559   return jresult;
29560 }
29561
29562
29563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29564   void * jresult ;
29565   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29566   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29567
29568   arg1 = (Dali::RenderTask *)jarg1;
29569   {
29570     try {
29571       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29572     } catch (std::out_of_range& e) {
29573       {
29574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29575       };
29576     } catch (std::exception& e) {
29577       {
29578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29579       };
29580     } catch (Dali::DaliException e) {
29581       {
29582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29583       };
29584     } catch (...) {
29585       {
29586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29587       };
29588     }
29589   }
29590
29591   jresult = (void *)result;
29592   return jresult;
29593 }
29594
29595
29596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29597   void * jresult ;
29598   int arg1 ;
29599   Dali::TouchPoint::State arg2 ;
29600   float arg3 ;
29601   float arg4 ;
29602   Dali::TouchPoint *result = 0 ;
29603
29604   arg1 = (int)jarg1;
29605   arg2 = (Dali::TouchPoint::State)jarg2;
29606   arg3 = (float)jarg3;
29607   arg4 = (float)jarg4;
29608   {
29609     try {
29610       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29611     } catch (std::out_of_range& e) {
29612       {
29613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29614       };
29615     } catch (std::exception& e) {
29616       {
29617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29618       };
29619     } catch (Dali::DaliException e) {
29620       {
29621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29622       };
29623     } catch (...) {
29624       {
29625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29626       };
29627     }
29628   }
29629
29630   jresult = (void *)result;
29631   return jresult;
29632 }
29633
29634
29635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29636   void * jresult ;
29637   int arg1 ;
29638   Dali::TouchPoint::State arg2 ;
29639   float arg3 ;
29640   float arg4 ;
29641   float arg5 ;
29642   float arg6 ;
29643   Dali::TouchPoint *result = 0 ;
29644
29645   arg1 = (int)jarg1;
29646   arg2 = (Dali::TouchPoint::State)jarg2;
29647   arg3 = (float)jarg3;
29648   arg4 = (float)jarg4;
29649   arg5 = (float)jarg5;
29650   arg6 = (float)jarg6;
29651   {
29652     try {
29653       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29654     } catch (std::out_of_range& e) {
29655       {
29656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29657       };
29658     } catch (std::exception& e) {
29659       {
29660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29661       };
29662     } catch (Dali::DaliException e) {
29663       {
29664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29665       };
29666     } catch (...) {
29667       {
29668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29669       };
29670     }
29671   }
29672
29673   jresult = (void *)result;
29674   return jresult;
29675 }
29676
29677
29678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29679   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29680
29681   arg1 = (Dali::TouchPoint *)jarg1;
29682   {
29683     try {
29684       delete arg1;
29685     } catch (std::out_of_range& e) {
29686       {
29687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29688       };
29689     } catch (std::exception& e) {
29690       {
29691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29692       };
29693     } catch (Dali::DaliException e) {
29694       {
29695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29696       };
29697     } catch (...) {
29698       {
29699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29700       };
29701     }
29702   }
29703
29704 }
29705
29706
29707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29708   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29709   int arg2 ;
29710
29711   arg1 = (Dali::TouchPoint *)jarg1;
29712   arg2 = (int)jarg2;
29713   if (arg1) (arg1)->deviceId = arg2;
29714 }
29715
29716
29717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29718   int jresult ;
29719   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29720   int result;
29721
29722   arg1 = (Dali::TouchPoint *)jarg1;
29723   result = (int) ((arg1)->deviceId);
29724   jresult = result;
29725   return jresult;
29726 }
29727
29728
29729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29730   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29731   Dali::TouchPoint::State arg2 ;
29732
29733   arg1 = (Dali::TouchPoint *)jarg1;
29734   arg2 = (Dali::TouchPoint::State)jarg2;
29735   if (arg1) (arg1)->state = arg2;
29736 }
29737
29738
29739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29740   int jresult ;
29741   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29742   Dali::TouchPoint::State result;
29743
29744   arg1 = (Dali::TouchPoint *)jarg1;
29745   result = (Dali::TouchPoint::State) ((arg1)->state);
29746   jresult = (int)result;
29747   return jresult;
29748 }
29749
29750
29751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29752   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29753   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29754
29755   arg1 = (Dali::TouchPoint *)jarg1;
29756   arg2 = (Dali::Actor *)jarg2;
29757   if (arg1) (arg1)->hitActor = *arg2;
29758 }
29759
29760
29761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29762   void * jresult ;
29763   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29764   Dali::Actor *result = 0 ;
29765
29766   arg1 = (Dali::TouchPoint *)jarg1;
29767   result = (Dali::Actor *)& ((arg1)->hitActor);
29768   jresult = (void *)result;
29769   return jresult;
29770 }
29771
29772
29773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29774   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29775   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29776
29777   arg1 = (Dali::TouchPoint *)jarg1;
29778   arg2 = (Dali::Vector2 *)jarg2;
29779   if (arg1) (arg1)->local = *arg2;
29780 }
29781
29782
29783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29784   void * jresult ;
29785   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29786   Dali::Vector2 *result = 0 ;
29787
29788   arg1 = (Dali::TouchPoint *)jarg1;
29789   result = (Dali::Vector2 *)& ((arg1)->local);
29790   jresult = (void *)result;
29791   return jresult;
29792 }
29793
29794
29795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29796   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29797   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29798
29799   arg1 = (Dali::TouchPoint *)jarg1;
29800   arg2 = (Dali::Vector2 *)jarg2;
29801   if (arg1) (arg1)->screen = *arg2;
29802 }
29803
29804
29805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29806   void * jresult ;
29807   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29808   Dali::Vector2 *result = 0 ;
29809
29810   arg1 = (Dali::TouchPoint *)jarg1;
29811   result = (Dali::Vector2 *)& ((arg1)->screen);
29812   jresult = (void *)result;
29813   return jresult;
29814 }
29815
29816
29817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29818   void * jresult ;
29819   Dali::TouchData *result = 0 ;
29820
29821   {
29822     try {
29823       result = (Dali::TouchData *)new Dali::TouchData();
29824     } catch (std::out_of_range& e) {
29825       {
29826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29827       };
29828     } catch (std::exception& e) {
29829       {
29830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29831       };
29832     } catch (Dali::DaliException e) {
29833       {
29834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29835       };
29836     } catch (...) {
29837       {
29838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29839       };
29840     }
29841   }
29842
29843   jresult = (void *)result;
29844   return jresult;
29845 }
29846
29847
29848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29849   void * jresult ;
29850   Dali::TouchData *arg1 = 0 ;
29851   Dali::TouchData *result = 0 ;
29852
29853   arg1 = (Dali::TouchData *)jarg1;
29854   if (!arg1) {
29855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29856     return 0;
29857   }
29858   {
29859     try {
29860       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29861     } catch (std::out_of_range& e) {
29862       {
29863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29864       };
29865     } catch (std::exception& e) {
29866       {
29867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29868       };
29869     } catch (Dali::DaliException e) {
29870       {
29871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29872       };
29873     } catch (...) {
29874       {
29875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29876       };
29877     }
29878   }
29879
29880   jresult = (void *)result;
29881   return jresult;
29882 }
29883
29884
29885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29886   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29887
29888   arg1 = (Dali::TouchData *)jarg1;
29889   {
29890     try {
29891       delete arg1;
29892     } catch (std::out_of_range& e) {
29893       {
29894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29895       };
29896     } catch (std::exception& e) {
29897       {
29898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29899       };
29900     } catch (Dali::DaliException e) {
29901       {
29902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29903       };
29904     } catch (...) {
29905       {
29906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29907       };
29908     }
29909   }
29910
29911 }
29912
29913
29914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29915   void * jresult ;
29916   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29917   Dali::TouchData *arg2 = 0 ;
29918   Dali::TouchData *result = 0 ;
29919
29920   arg1 = (Dali::TouchData *)jarg1;
29921   arg2 = (Dali::TouchData *)jarg2;
29922   if (!arg2) {
29923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29924     return 0;
29925   }
29926   {
29927     try {
29928       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29929     } catch (std::out_of_range& e) {
29930       {
29931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29932       };
29933     } catch (std::exception& e) {
29934       {
29935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29936       };
29937     } catch (Dali::DaliException e) {
29938       {
29939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29940       };
29941     } catch (...) {
29942       {
29943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29944       };
29945     }
29946   }
29947
29948   jresult = (void *)result;
29949   return jresult;
29950 }
29951
29952
29953 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29954   unsigned long jresult ;
29955   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29956   unsigned long result;
29957
29958   arg1 = (Dali::TouchData *)jarg1;
29959   {
29960     try {
29961       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29962     } catch (std::out_of_range& e) {
29963       {
29964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29965       };
29966     } catch (std::exception& e) {
29967       {
29968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29969       };
29970     } catch (Dali::DaliException e) {
29971       {
29972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29973       };
29974     } catch (...) {
29975       {
29976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29977       };
29978     }
29979   }
29980
29981   jresult = (unsigned long)result;
29982   return jresult;
29983 }
29984
29985
29986 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29987   unsigned long jresult ;
29988   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29989   std::size_t result;
29990
29991   arg1 = (Dali::TouchData *)jarg1;
29992   {
29993     try {
29994       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29995     } catch (std::out_of_range& e) {
29996       {
29997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29998       };
29999     } catch (std::exception& e) {
30000       {
30001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30002       };
30003     } catch (Dali::DaliException e) {
30004       {
30005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30006       };
30007     } catch (...) {
30008       {
30009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30010       };
30011     }
30012   }
30013
30014   jresult = (unsigned long)result;
30015   return jresult;
30016 }
30017
30018
30019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
30020   int jresult ;
30021   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30022   std::size_t arg2 ;
30023   int32_t result;
30024
30025   arg1 = (Dali::TouchData *)jarg1;
30026   arg2 = (std::size_t)jarg2;
30027   {
30028     try {
30029       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
30030     } catch (std::out_of_range& e) {
30031       {
30032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30033       };
30034     } catch (std::exception& e) {
30035       {
30036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30037       };
30038     } catch (Dali::DaliException e) {
30039       {
30040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30041       };
30042     } catch (...) {
30043       {
30044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30045       };
30046     }
30047   }
30048
30049   jresult = result;
30050   return jresult;
30051 }
30052
30053
30054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
30055   int jresult ;
30056   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30057   std::size_t arg2 ;
30058   Dali::PointState::Type result;
30059
30060   arg1 = (Dali::TouchData *)jarg1;
30061   arg2 = (std::size_t)jarg2;
30062   {
30063     try {
30064       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
30065     } catch (std::out_of_range& e) {
30066       {
30067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30068       };
30069     } catch (std::exception& e) {
30070       {
30071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30072       };
30073     } catch (Dali::DaliException e) {
30074       {
30075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30076       };
30077     } catch (...) {
30078       {
30079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30080       };
30081     }
30082   }
30083
30084   jresult = (int)result;
30085   return jresult;
30086 }
30087
30088
30089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30090   void * jresult ;
30091   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30092   std::size_t arg2 ;
30093   Dali::Actor result;
30094
30095   arg1 = (Dali::TouchData *)jarg1;
30096   arg2 = (std::size_t)jarg2;
30097   {
30098     try {
30099       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30100     } catch (std::out_of_range& e) {
30101       {
30102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30103       };
30104     } catch (std::exception& e) {
30105       {
30106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30107       };
30108     } catch (Dali::DaliException e) {
30109       {
30110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30111       };
30112     } catch (...) {
30113       {
30114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30115       };
30116     }
30117   }
30118
30119   jresult = new Dali::Actor((const Dali::Actor &)result);
30120   return jresult;
30121 }
30122
30123
30124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30125   void * jresult ;
30126   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30127   std::size_t arg2 ;
30128   Dali::Vector2 *result = 0 ;
30129
30130   arg1 = (Dali::TouchData *)jarg1;
30131   arg2 = (std::size_t)jarg2;
30132   {
30133     try {
30134       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30135     } catch (std::out_of_range& e) {
30136       {
30137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30138       };
30139     } catch (std::exception& e) {
30140       {
30141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30142       };
30143     } catch (Dali::DaliException e) {
30144       {
30145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30146       };
30147     } catch (...) {
30148       {
30149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30150       };
30151     }
30152   }
30153
30154   jresult = (void *)result;
30155   return jresult;
30156 }
30157
30158
30159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30160   void * jresult ;
30161   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30162   std::size_t arg2 ;
30163   Dali::Vector2 *result = 0 ;
30164
30165   arg1 = (Dali::TouchData *)jarg1;
30166   arg2 = (std::size_t)jarg2;
30167   {
30168     try {
30169       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30170     } catch (std::out_of_range& e) {
30171       {
30172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30173       };
30174     } catch (std::exception& e) {
30175       {
30176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30177       };
30178     } catch (Dali::DaliException e) {
30179       {
30180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30181       };
30182     } catch (...) {
30183       {
30184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30185       };
30186     }
30187   }
30188
30189   jresult = (void *)result;
30190   return jresult;
30191 }
30192
30193
30194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30195   float jresult ;
30196   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30197   std::size_t arg2 ;
30198   float result;
30199
30200   arg1 = (Dali::TouchData *)jarg1;
30201   arg2 = (std::size_t)jarg2;
30202   {
30203     try {
30204       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30205     } catch (std::out_of_range& e) {
30206       {
30207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30208       };
30209     } catch (std::exception& e) {
30210       {
30211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30212       };
30213     } catch (Dali::DaliException e) {
30214       {
30215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30216       };
30217     } catch (...) {
30218       {
30219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30220       };
30221     }
30222   }
30223
30224   jresult = result;
30225   return jresult;
30226 }
30227
30228
30229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30230   void * jresult ;
30231   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30232   std::size_t arg2 ;
30233   Dali::Vector2 *result = 0 ;
30234
30235   arg1 = (Dali::TouchData *)jarg1;
30236   arg2 = (std::size_t)jarg2;
30237   {
30238     try {
30239       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30240     } catch (std::out_of_range& e) {
30241       {
30242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30243       };
30244     } catch (std::exception& e) {
30245       {
30246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30247       };
30248     } catch (Dali::DaliException e) {
30249       {
30250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30251       };
30252     } catch (...) {
30253       {
30254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30255       };
30256     }
30257   }
30258
30259   jresult = (void *)result;
30260   return jresult;
30261 }
30262
30263
30264 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30265   float jresult ;
30266   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30267   std::size_t arg2 ;
30268   float result;
30269
30270   arg1 = (Dali::TouchData *)jarg1;
30271   arg2 = (std::size_t)jarg2;
30272   {
30273     try {
30274       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30275     } catch (std::out_of_range& e) {
30276       {
30277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30278       };
30279     } catch (std::exception& e) {
30280       {
30281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30282       };
30283     } catch (Dali::DaliException e) {
30284       {
30285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30286       };
30287     } catch (...) {
30288       {
30289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30290       };
30291     }
30292   }
30293
30294   jresult = result;
30295   return jresult;
30296 }
30297
30298
30299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30300   void * jresult ;
30301   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30302   std::size_t arg2 ;
30303   Dali::Degree result;
30304
30305   arg1 = (Dali::TouchData *)jarg1;
30306   arg2 = (std::size_t)jarg2;
30307   {
30308     try {
30309       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30310     } catch (std::out_of_range& e) {
30311       {
30312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30313       };
30314     } catch (std::exception& e) {
30315       {
30316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30317       };
30318     } catch (Dali::DaliException e) {
30319       {
30320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30321       };
30322     } catch (...) {
30323       {
30324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30325       };
30326     }
30327   }
30328
30329   jresult = new Dali::Degree((const Dali::Degree &)result);
30330   return jresult;
30331 }
30332
30333
30334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30335   int jresult ;
30336   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30337   std::size_t arg2 ;
30338   Dali::MouseButton::Type result;
30339
30340   arg1 = (Dali::TouchData *)jarg1;
30341   arg2 = (std::size_t)jarg2;
30342   {
30343     try {
30344       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30345     } catch (std::out_of_range& e) {
30346       {
30347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30348       };
30349     } catch (std::exception& e) {
30350       {
30351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30352       };
30353     } catch (Dali::DaliException e) {
30354       {
30355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30356       };
30357     } catch (...) {
30358       {
30359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30360       };
30361     }
30362   }
30363
30364   jresult = static_cast< int >(result);
30365   return jresult;
30366 }
30367
30368
30369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30370   void * jresult ;
30371   Dali::GestureDetector *result = 0 ;
30372
30373   {
30374     try {
30375       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30376     } catch (std::out_of_range& e) {
30377       {
30378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30379       };
30380     } catch (std::exception& e) {
30381       {
30382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30383       };
30384     } catch (Dali::DaliException e) {
30385       {
30386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30387       };
30388     } catch (...) {
30389       {
30390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30391       };
30392     }
30393   }
30394
30395   jresult = (void *)result;
30396   return jresult;
30397 }
30398
30399
30400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30401   void * jresult ;
30402   Dali::BaseHandle arg1 ;
30403   Dali::BaseHandle *argp1 ;
30404   Dali::GestureDetector result;
30405
30406   argp1 = (Dali::BaseHandle *)jarg1;
30407   if (!argp1) {
30408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30409     return 0;
30410   }
30411   arg1 = *argp1;
30412   {
30413     try {
30414       result = Dali::GestureDetector::DownCast(arg1);
30415     } catch (std::out_of_range& e) {
30416       {
30417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30418       };
30419     } catch (std::exception& e) {
30420       {
30421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30422       };
30423     } catch (Dali::DaliException e) {
30424       {
30425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30426       };
30427     } catch (...) {
30428       {
30429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30430       };
30431     }
30432   }
30433
30434   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30435   return jresult;
30436 }
30437
30438
30439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30440   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30441
30442   arg1 = (Dali::GestureDetector *)jarg1;
30443   {
30444     try {
30445       delete arg1;
30446     } catch (std::out_of_range& e) {
30447       {
30448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30449       };
30450     } catch (std::exception& e) {
30451       {
30452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30453       };
30454     } catch (Dali::DaliException e) {
30455       {
30456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30457       };
30458     } catch (...) {
30459       {
30460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30461       };
30462     }
30463   }
30464
30465 }
30466
30467
30468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30469   void * jresult ;
30470   Dali::GestureDetector *arg1 = 0 ;
30471   Dali::GestureDetector *result = 0 ;
30472
30473   arg1 = (Dali::GestureDetector *)jarg1;
30474   if (!arg1) {
30475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30476     return 0;
30477   }
30478   {
30479     try {
30480       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30481     } catch (std::out_of_range& e) {
30482       {
30483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30484       };
30485     } catch (std::exception& e) {
30486       {
30487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30488       };
30489     } catch (Dali::DaliException e) {
30490       {
30491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30492       };
30493     } catch (...) {
30494       {
30495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30496       };
30497     }
30498   }
30499
30500   jresult = (void *)result;
30501   return jresult;
30502 }
30503
30504
30505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30506   void * jresult ;
30507   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30508   Dali::GestureDetector *arg2 = 0 ;
30509   Dali::GestureDetector *result = 0 ;
30510
30511   arg1 = (Dali::GestureDetector *)jarg1;
30512   arg2 = (Dali::GestureDetector *)jarg2;
30513   if (!arg2) {
30514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30515     return 0;
30516   }
30517   {
30518     try {
30519       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30520     } catch (std::out_of_range& e) {
30521       {
30522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30523       };
30524     } catch (std::exception& e) {
30525       {
30526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30527       };
30528     } catch (Dali::DaliException e) {
30529       {
30530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30531       };
30532     } catch (...) {
30533       {
30534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30535       };
30536     }
30537   }
30538
30539   jresult = (void *)result;
30540   return jresult;
30541 }
30542
30543
30544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30545   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30546   Dali::Actor arg2 ;
30547   Dali::Actor *argp2 ;
30548
30549   arg1 = (Dali::GestureDetector *)jarg1;
30550   argp2 = (Dali::Actor *)jarg2;
30551   if (!argp2) {
30552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30553     return ;
30554   }
30555   arg2 = *argp2;
30556   {
30557     try {
30558       (arg1)->Attach(arg2);
30559     } catch (std::out_of_range& e) {
30560       {
30561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30562       };
30563     } catch (std::exception& e) {
30564       {
30565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30566       };
30567     } catch (Dali::DaliException e) {
30568       {
30569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30570       };
30571     } catch (...) {
30572       {
30573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30574       };
30575     }
30576   }
30577
30578 }
30579
30580
30581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30582   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30583   Dali::Actor arg2 ;
30584   Dali::Actor *argp2 ;
30585
30586   arg1 = (Dali::GestureDetector *)jarg1;
30587   argp2 = (Dali::Actor *)jarg2;
30588   if (!argp2) {
30589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30590     return ;
30591   }
30592   arg2 = *argp2;
30593   {
30594     try {
30595       (arg1)->Detach(arg2);
30596     } catch (std::out_of_range& e) {
30597       {
30598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30599       };
30600     } catch (std::exception& e) {
30601       {
30602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30603       };
30604     } catch (Dali::DaliException e) {
30605       {
30606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30607       };
30608     } catch (...) {
30609       {
30610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30611       };
30612     }
30613   }
30614
30615 }
30616
30617
30618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30619   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30620
30621   arg1 = (Dali::GestureDetector *)jarg1;
30622   {
30623     try {
30624       (arg1)->DetachAll();
30625     } catch (std::out_of_range& e) {
30626       {
30627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30628       };
30629     } catch (std::exception& e) {
30630       {
30631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30632       };
30633     } catch (Dali::DaliException e) {
30634       {
30635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30636       };
30637     } catch (...) {
30638       {
30639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30640       };
30641     }
30642   }
30643
30644 }
30645
30646
30647 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30648   unsigned long jresult ;
30649   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30650   size_t result;
30651
30652   arg1 = (Dali::GestureDetector *)jarg1;
30653   {
30654     try {
30655       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30656     } catch (std::out_of_range& e) {
30657       {
30658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30659       };
30660     } catch (std::exception& e) {
30661       {
30662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30663       };
30664     } catch (Dali::DaliException e) {
30665       {
30666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30667       };
30668     } catch (...) {
30669       {
30670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30671       };
30672     }
30673   }
30674
30675   jresult = (unsigned long)result;
30676   return jresult;
30677 }
30678
30679
30680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30681   void * jresult ;
30682   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30683   size_t arg2 ;
30684   Dali::Actor result;
30685
30686   arg1 = (Dali::GestureDetector *)jarg1;
30687   arg2 = (size_t)jarg2;
30688   {
30689     try {
30690       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30691     } catch (std::out_of_range& e) {
30692       {
30693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30694       };
30695     } catch (std::exception& e) {
30696       {
30697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30698       };
30699     } catch (Dali::DaliException e) {
30700       {
30701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30702       };
30703     } catch (...) {
30704       {
30705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30706       };
30707     }
30708   }
30709
30710   jresult = new Dali::Actor((const Dali::Actor &)result);
30711   return jresult;
30712 }
30713
30714
30715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30716   void * jresult ;
30717   Dali::Gesture *arg1 = 0 ;
30718   Dali::Gesture *result = 0 ;
30719
30720   arg1 = (Dali::Gesture *)jarg1;
30721   if (!arg1) {
30722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30723     return 0;
30724   }
30725   {
30726     try {
30727       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30728     } catch (std::out_of_range& e) {
30729       {
30730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30731       };
30732     } catch (std::exception& e) {
30733       {
30734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30735       };
30736     } catch (Dali::DaliException e) {
30737       {
30738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30739       };
30740     } catch (...) {
30741       {
30742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30743       };
30744     }
30745   }
30746
30747   jresult = (void *)result;
30748   return jresult;
30749 }
30750
30751
30752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30753   void * jresult ;
30754   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30755   Dali::Gesture *arg2 = 0 ;
30756   Dali::Gesture *result = 0 ;
30757
30758   arg1 = (Dali::Gesture *)jarg1;
30759   arg2 = (Dali::Gesture *)jarg2;
30760   if (!arg2) {
30761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30762     return 0;
30763   }
30764   {
30765     try {
30766       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30767     } catch (std::out_of_range& e) {
30768       {
30769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30770       };
30771     } catch (std::exception& e) {
30772       {
30773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30774       };
30775     } catch (Dali::DaliException e) {
30776       {
30777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30778       };
30779     } catch (...) {
30780       {
30781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30782       };
30783     }
30784   }
30785
30786   jresult = (void *)result;
30787   return jresult;
30788 }
30789
30790
30791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30792   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30793
30794   arg1 = (Dali::Gesture *)jarg1;
30795   {
30796     try {
30797       delete arg1;
30798     } catch (std::out_of_range& e) {
30799       {
30800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30801       };
30802     } catch (std::exception& e) {
30803       {
30804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30805       };
30806     } catch (Dali::DaliException e) {
30807       {
30808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30809       };
30810     } catch (...) {
30811       {
30812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30813       };
30814     }
30815   }
30816
30817 }
30818
30819
30820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30821   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30822   Dali::Gesture::Type arg2 ;
30823
30824   arg1 = (Dali::Gesture *)jarg1;
30825   arg2 = (Dali::Gesture::Type)jarg2;
30826   if (arg1) (arg1)->type = arg2;
30827 }
30828
30829
30830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30831   int jresult ;
30832   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30833   Dali::Gesture::Type result;
30834
30835   arg1 = (Dali::Gesture *)jarg1;
30836   result = (Dali::Gesture::Type) ((arg1)->type);
30837   jresult = (int)result;
30838   return jresult;
30839 }
30840
30841
30842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30843   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30844   Dali::Gesture::State arg2 ;
30845
30846   arg1 = (Dali::Gesture *)jarg1;
30847   arg2 = (Dali::Gesture::State)jarg2;
30848   if (arg1) (arg1)->state = arg2;
30849 }
30850
30851
30852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30853   int jresult ;
30854   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30855   Dali::Gesture::State result;
30856
30857   arg1 = (Dali::Gesture *)jarg1;
30858   result = (Dali::Gesture::State) ((arg1)->state);
30859   jresult = (int)result;
30860   return jresult;
30861 }
30862
30863
30864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30865   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30866   unsigned int arg2 ;
30867
30868   arg1 = (Dali::Gesture *)jarg1;
30869   arg2 = (unsigned int)jarg2;
30870   if (arg1) (arg1)->time = arg2;
30871 }
30872
30873
30874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30875   unsigned int jresult ;
30876   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30877   unsigned int result;
30878
30879   arg1 = (Dali::Gesture *)jarg1;
30880   result = (unsigned int) ((arg1)->time);
30881   jresult = result;
30882   return jresult;
30883 }
30884
30885
30886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30887   void * jresult ;
30888   Dali::HoverEvent *result = 0 ;
30889
30890   {
30891     try {
30892       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30893     } catch (std::out_of_range& e) {
30894       {
30895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30896       };
30897     } catch (std::exception& e) {
30898       {
30899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30900       };
30901     } catch (Dali::DaliException e) {
30902       {
30903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30904       };
30905     } catch (...) {
30906       {
30907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30908       };
30909     }
30910   }
30911
30912   jresult = (void *)result;
30913   return jresult;
30914 }
30915
30916
30917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30918   void * jresult ;
30919   unsigned long arg1 ;
30920   Dali::HoverEvent *result = 0 ;
30921
30922   arg1 = (unsigned long)jarg1;
30923   {
30924     try {
30925       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30926     } catch (std::out_of_range& e) {
30927       {
30928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30929       };
30930     } catch (std::exception& e) {
30931       {
30932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30933       };
30934     } catch (Dali::DaliException e) {
30935       {
30936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30937       };
30938     } catch (...) {
30939       {
30940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30941       };
30942     }
30943   }
30944
30945   jresult = (void *)result;
30946   return jresult;
30947 }
30948
30949
30950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30951   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30952
30953   arg1 = (Dali::HoverEvent *)jarg1;
30954   {
30955     try {
30956       delete arg1;
30957     } catch (std::out_of_range& e) {
30958       {
30959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30960       };
30961     } catch (std::exception& e) {
30962       {
30963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30964       };
30965     } catch (Dali::DaliException e) {
30966       {
30967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30968       };
30969     } catch (...) {
30970       {
30971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30972       };
30973     }
30974   }
30975
30976 }
30977
30978
30979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30980   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30981   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30982
30983   arg1 = (Dali::HoverEvent *)jarg1;
30984   arg2 = (Dali::TouchPointContainer *)jarg2;
30985   if (arg1) (arg1)->points = *arg2;
30986 }
30987
30988
30989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30990   void * jresult ;
30991   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30992   Dali::TouchPointContainer *result = 0 ;
30993
30994   arg1 = (Dali::HoverEvent *)jarg1;
30995   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30996   jresult = (void *)result;
30997   return jresult;
30998 }
30999
31000
31001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
31002   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31003   unsigned long arg2 ;
31004
31005   arg1 = (Dali::HoverEvent *)jarg1;
31006   arg2 = (unsigned long)jarg2;
31007   if (arg1) (arg1)->time = arg2;
31008 }
31009
31010
31011 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
31012   unsigned long jresult ;
31013   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31014   unsigned long result;
31015
31016   arg1 = (Dali::HoverEvent *)jarg1;
31017   result = (unsigned long) ((arg1)->time);
31018   jresult = (unsigned long)result;
31019   return jresult;
31020 }
31021
31022
31023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
31024   unsigned int jresult ;
31025   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31026   unsigned int result;
31027
31028   arg1 = (Dali::HoverEvent *)jarg1;
31029   {
31030     try {
31031       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
31032     } catch (std::out_of_range& e) {
31033       {
31034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31035       };
31036     } catch (std::exception& e) {
31037       {
31038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31039       };
31040     } catch (Dali::DaliException e) {
31041       {
31042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31043       };
31044     } catch (...) {
31045       {
31046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31047       };
31048     }
31049   }
31050
31051   jresult = result;
31052   return jresult;
31053 }
31054
31055
31056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
31057   void * jresult ;
31058   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31059   unsigned int arg2 ;
31060   Dali::TouchPoint *result = 0 ;
31061
31062   arg1 = (Dali::HoverEvent *)jarg1;
31063   arg2 = (unsigned int)jarg2;
31064   {
31065     try {
31066       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
31067     } catch (std::out_of_range& e) {
31068       {
31069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31070       };
31071     } catch (std::exception& e) {
31072       {
31073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31074       };
31075     } catch (Dali::DaliException e) {
31076       {
31077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31078       };
31079     } catch (...) {
31080       {
31081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31082       };
31083     }
31084   }
31085
31086   jresult = (void *)result;
31087   return jresult;
31088 }
31089
31090
31091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31092   void * jresult ;
31093   Dali::KeyEvent *result = 0 ;
31094
31095   {
31096     try {
31097       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31098     } catch (std::out_of_range& e) {
31099       {
31100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31101       };
31102     } catch (std::exception& e) {
31103       {
31104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31105       };
31106     } catch (Dali::DaliException e) {
31107       {
31108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31109       };
31110     } catch (...) {
31111       {
31112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31113       };
31114     }
31115   }
31116
31117   jresult = (void *)result;
31118   return jresult;
31119 }
31120
31121
31122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31123   void * jresult ;
31124   std::string *arg1 = 0 ;
31125   std::string *arg2 = 0 ;
31126   int arg3 ;
31127   int arg4 ;
31128   unsigned long arg5 ;
31129   Dali::KeyEvent::State *arg6 = 0 ;
31130   Dali::KeyEvent::State temp6 ;
31131   Dali::KeyEvent *result = 0 ;
31132
31133   if (!jarg1) {
31134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31135     return 0;
31136   }
31137   std::string arg1_str(jarg1);
31138   arg1 = &arg1_str;
31139   if (!jarg2) {
31140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31141     return 0;
31142   }
31143   std::string arg2_str(jarg2);
31144   arg2 = &arg2_str;
31145   arg3 = (int)jarg3;
31146   arg4 = (int)jarg4;
31147   arg5 = (unsigned long)jarg5;
31148   temp6 = (Dali::KeyEvent::State)jarg6;
31149   arg6 = &temp6;
31150   {
31151     try {
31152       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31153     } catch (std::out_of_range& e) {
31154       {
31155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31156       };
31157     } catch (std::exception& e) {
31158       {
31159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31160       };
31161     } catch (Dali::DaliException e) {
31162       {
31163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31164       };
31165     } catch (...) {
31166       {
31167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31168       };
31169     }
31170   }
31171
31172   jresult = (void *)result;
31173
31174   //argout typemap for const std::string&
31175
31176
31177   //argout typemap for const std::string&
31178
31179   return jresult;
31180 }
31181
31182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31183   void * jresult ;
31184   Dali::KeyEvent *arg1 = 0 ;
31185   Dali::KeyEvent *result = 0 ;
31186
31187   arg1 = (Dali::KeyEvent *)jarg1;
31188   if (!arg1) {
31189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31190     return 0;
31191   }
31192   {
31193     try {
31194       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31195     } catch (std::out_of_range& e) {
31196       {
31197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31198       };
31199     } catch (std::exception& e) {
31200       {
31201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31202       };
31203     } catch (Dali::DaliException e) {
31204       {
31205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31206       };
31207     } catch (...) {
31208       {
31209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31210       };
31211     }
31212   }
31213
31214   jresult = (void *)result;
31215   return jresult;
31216 }
31217
31218
31219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31220   void * jresult ;
31221   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31222   Dali::KeyEvent *arg2 = 0 ;
31223   Dali::KeyEvent *result = 0 ;
31224
31225   arg1 = (Dali::KeyEvent *)jarg1;
31226   arg2 = (Dali::KeyEvent *)jarg2;
31227   if (!arg2) {
31228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31229     return 0;
31230   }
31231   {
31232     try {
31233       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31234     } catch (std::out_of_range& e) {
31235       {
31236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31237       };
31238     } catch (std::exception& e) {
31239       {
31240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31241       };
31242     } catch (Dali::DaliException e) {
31243       {
31244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31245       };
31246     } catch (...) {
31247       {
31248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31249       };
31250     }
31251   }
31252
31253   jresult = (void *)result;
31254   return jresult;
31255 }
31256
31257
31258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31259   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31260
31261   arg1 = (Dali::KeyEvent *)jarg1;
31262   {
31263     try {
31264       delete arg1;
31265     } catch (std::out_of_range& e) {
31266       {
31267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31268       };
31269     } catch (std::exception& e) {
31270       {
31271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31272       };
31273     } catch (Dali::DaliException e) {
31274       {
31275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31276       };
31277     } catch (...) {
31278       {
31279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31280       };
31281     }
31282   }
31283
31284 }
31285
31286
31287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31288   unsigned int jresult ;
31289   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31290   bool result;
31291
31292   arg1 = (Dali::KeyEvent *)jarg1;
31293   {
31294     try {
31295       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31296     } catch (std::out_of_range& e) {
31297       {
31298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31299       };
31300     } catch (std::exception& e) {
31301       {
31302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31303       };
31304     } catch (Dali::DaliException e) {
31305       {
31306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31307       };
31308     } catch (...) {
31309       {
31310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31311       };
31312     }
31313   }
31314
31315   jresult = result;
31316   return jresult;
31317 }
31318
31319
31320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31321   unsigned int jresult ;
31322   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31323   bool result;
31324
31325   arg1 = (Dali::KeyEvent *)jarg1;
31326   {
31327     try {
31328       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31329     } catch (std::out_of_range& e) {
31330       {
31331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31332       };
31333     } catch (std::exception& e) {
31334       {
31335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31336       };
31337     } catch (Dali::DaliException e) {
31338       {
31339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31340       };
31341     } catch (...) {
31342       {
31343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31344       };
31345     }
31346   }
31347
31348   jresult = result;
31349   return jresult;
31350 }
31351
31352
31353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31354   unsigned int jresult ;
31355   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31356   bool result;
31357
31358   arg1 = (Dali::KeyEvent *)jarg1;
31359   {
31360     try {
31361       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31362     } catch (std::out_of_range& e) {
31363       {
31364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31365       };
31366     } catch (std::exception& e) {
31367       {
31368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31369       };
31370     } catch (Dali::DaliException e) {
31371       {
31372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31373       };
31374     } catch (...) {
31375       {
31376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31377       };
31378     }
31379   }
31380
31381   jresult = result;
31382   return jresult;
31383 }
31384
31385
31386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31387   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31388   std::string *arg2 = 0 ;
31389
31390   arg1 = (Dali::KeyEvent *)jarg1;
31391   if (!jarg2) {
31392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31393     return ;
31394   }
31395   std::string arg2_str(jarg2);
31396   arg2 = &arg2_str;
31397   if (arg1) (arg1)->keyPressedName = *arg2;
31398
31399   //argout typemap for const std::string&
31400
31401 }
31402
31403
31404 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31405   char * jresult ;
31406
31407   if( jarg1 == NULL )
31408   {
31409     jresult = SWIG_csharp_string_callback( "" );
31410   }
31411   else
31412   {
31413     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31414     std::string *result = 0;
31415
31416     arg1 = ( Dali::KeyEvent * )jarg1;
31417     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31418     jresult = SWIG_csharp_string_callback( result->c_str() );
31419   }
31420
31421   return jresult;
31422 }
31423
31424
31425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31426   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31427   std::string *arg2 = 0 ;
31428
31429   arg1 = (Dali::KeyEvent *)jarg1;
31430   if (!jarg2) {
31431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31432     return ;
31433   }
31434   std::string arg2_str(jarg2);
31435   arg2 = &arg2_str;
31436   if (arg1) (arg1)->keyPressed = *arg2;
31437
31438   //argout typemap for const std::string&
31439
31440 }
31441
31442
31443 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31444   char * jresult ;
31445   if( NULL == jarg1 )
31446   {
31447     jresult = SWIG_csharp_string_callback( "" );
31448   }
31449   else
31450   {
31451     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31452     std::string *result = 0;
31453
31454     arg1 = ( Dali::KeyEvent * )jarg1;
31455     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31456     jresult = SWIG_csharp_string_callback( result->c_str() );
31457   }
31458   return jresult;
31459 }
31460
31461
31462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31463   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31464   int arg2 ;
31465
31466   arg1 = (Dali::KeyEvent *)jarg1;
31467   arg2 = (int)jarg2;
31468   if (arg1) (arg1)->keyCode = arg2;
31469 }
31470
31471
31472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31473   int jresult ;
31474   if( NULL == jarg1 )
31475   {
31476     jresult = -1;
31477   }
31478   else
31479   {
31480     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31481     int result;
31482
31483     arg1 = ( Dali::KeyEvent * )jarg1;
31484     result = (int)( ( arg1 )->keyCode );
31485     jresult = result;
31486   }
31487   return jresult;
31488 }
31489
31490
31491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31492   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31493   int arg2 ;
31494
31495   arg1 = (Dali::KeyEvent *)jarg1;
31496   arg2 = (int)jarg2;
31497   if (arg1) (arg1)->keyModifier = arg2;
31498 }
31499
31500
31501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31502   int jresult ;
31503   if( jarg1 == NULL )
31504   {
31505     jresult = -1;
31506   }
31507   else
31508   {
31509     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31510     int result;
31511
31512     arg1 = ( Dali::KeyEvent * )jarg1;
31513     result = (int)( ( arg1 )->keyModifier );
31514     jresult = result;
31515   }
31516   return jresult;
31517 }
31518
31519
31520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31521   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31522   unsigned long arg2 ;
31523
31524   arg1 = (Dali::KeyEvent *)jarg1;
31525   arg2 = (unsigned long)jarg2;
31526   if (arg1) (arg1)->time = arg2;
31527 }
31528
31529
31530 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31531   unsigned long jresult ;
31532   if( jarg1 == NULL )
31533   {
31534     jresult = 0;
31535   }
31536   else
31537   {
31538     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31539     unsigned long result;
31540
31541     arg1 = ( Dali::KeyEvent * )jarg1;
31542     result = (unsigned long)( ( arg1 )->time );
31543     jresult = (unsigned long)result;
31544   }
31545   return jresult;
31546 }
31547
31548
31549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31550   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31551   Dali::KeyEvent::State arg2 ;
31552
31553   arg1 = (Dali::KeyEvent *)jarg1;
31554   arg2 = (Dali::KeyEvent::State)jarg2;
31555   if (arg1) (arg1)->state = arg2;
31556 }
31557
31558
31559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31560   int jresult ;
31561   if( jarg1 == NULL )
31562   {
31563     jresult = -1;
31564   }
31565   else
31566   {
31567     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31568     Dali::KeyEvent::State result;
31569
31570     arg1 = ( Dali::KeyEvent * )jarg1;
31571     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31572     jresult = (int)result;
31573   }
31574   return jresult;
31575 }
31576
31577 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31578   char * jresult ;
31579   std::string result;
31580   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31581
31582   arg1 = (Dali::KeyEvent *)jarg1;
31583   if (!arg1) {
31584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31585     return 0;
31586   }
31587   {
31588     try {
31589       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31590     } catch (std::out_of_range& e) {
31591       {
31592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31593       };
31594     } catch (std::exception& e) {
31595       {
31596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31597       };
31598     } catch (Dali::DaliException e) {
31599       {
31600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31601       };
31602     } catch (...) {
31603       {
31604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31605       };
31606     }
31607
31608   }
31609
31610   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31611   return jresult;
31612 }
31613
31614
31615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31616   void * jresult ;
31617   Dali::LongPressGestureDetector *result = 0 ;
31618
31619   {
31620     try {
31621       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31622     } catch (std::out_of_range& e) {
31623       {
31624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31625       };
31626     } catch (std::exception& e) {
31627       {
31628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31629       };
31630     } catch (Dali::DaliException e) {
31631       {
31632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31633       };
31634     } catch (...) {
31635       {
31636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31637       };
31638     }
31639   }
31640
31641   jresult = (void *)result;
31642   return jresult;
31643 }
31644
31645
31646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31647   void * jresult ;
31648   Dali::LongPressGestureDetector result;
31649
31650   {
31651     try {
31652       result = Dali::LongPressGestureDetector::New();
31653     } catch (std::out_of_range& e) {
31654       {
31655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31656       };
31657     } catch (std::exception& e) {
31658       {
31659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31660       };
31661     } catch (Dali::DaliException e) {
31662       {
31663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31664       };
31665     } catch (...) {
31666       {
31667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31668       };
31669     }
31670   }
31671
31672   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31673   return jresult;
31674 }
31675
31676
31677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31678   void * jresult ;
31679   unsigned int arg1 ;
31680   Dali::LongPressGestureDetector result;
31681
31682   arg1 = (unsigned int)jarg1;
31683   {
31684     try {
31685       result = Dali::LongPressGestureDetector::New(arg1);
31686     } catch (std::out_of_range& e) {
31687       {
31688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31689       };
31690     } catch (std::exception& e) {
31691       {
31692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31693       };
31694     } catch (Dali::DaliException e) {
31695       {
31696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31697       };
31698     } catch (...) {
31699       {
31700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31701       };
31702     }
31703   }
31704
31705   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31706   return jresult;
31707 }
31708
31709
31710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31711   void * jresult ;
31712   unsigned int arg1 ;
31713   unsigned int arg2 ;
31714   Dali::LongPressGestureDetector result;
31715
31716   arg1 = (unsigned int)jarg1;
31717   arg2 = (unsigned int)jarg2;
31718   {
31719     try {
31720       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31721     } catch (std::out_of_range& e) {
31722       {
31723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31724       };
31725     } catch (std::exception& e) {
31726       {
31727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31728       };
31729     } catch (Dali::DaliException e) {
31730       {
31731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31732       };
31733     } catch (...) {
31734       {
31735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31736       };
31737     }
31738   }
31739
31740   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31741   return jresult;
31742 }
31743
31744
31745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31746   void * jresult ;
31747   Dali::BaseHandle arg1 ;
31748   Dali::BaseHandle *argp1 ;
31749   Dali::LongPressGestureDetector result;
31750
31751   argp1 = (Dali::BaseHandle *)jarg1;
31752   if (!argp1) {
31753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31754     return 0;
31755   }
31756   arg1 = *argp1;
31757   {
31758     try {
31759       result = Dali::LongPressGestureDetector::DownCast(arg1);
31760     } catch (std::out_of_range& e) {
31761       {
31762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31763       };
31764     } catch (std::exception& e) {
31765       {
31766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31767       };
31768     } catch (Dali::DaliException e) {
31769       {
31770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31771       };
31772     } catch (...) {
31773       {
31774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31775       };
31776     }
31777   }
31778
31779   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31780   return jresult;
31781 }
31782
31783
31784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31785   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31786
31787   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31788   {
31789     try {
31790       delete arg1;
31791     } catch (std::out_of_range& e) {
31792       {
31793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31794       };
31795     } catch (std::exception& e) {
31796       {
31797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31798       };
31799     } catch (Dali::DaliException e) {
31800       {
31801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31802       };
31803     } catch (...) {
31804       {
31805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31806       };
31807     }
31808   }
31809
31810 }
31811
31812
31813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31814   void * jresult ;
31815   Dali::LongPressGestureDetector *arg1 = 0 ;
31816   Dali::LongPressGestureDetector *result = 0 ;
31817
31818   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31819   if (!arg1) {
31820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31821     return 0;
31822   }
31823   {
31824     try {
31825       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31826     } catch (std::out_of_range& e) {
31827       {
31828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31829       };
31830     } catch (std::exception& e) {
31831       {
31832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31833       };
31834     } catch (Dali::DaliException e) {
31835       {
31836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31837       };
31838     } catch (...) {
31839       {
31840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31841       };
31842     }
31843   }
31844
31845   jresult = (void *)result;
31846   return jresult;
31847 }
31848
31849
31850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31851   void * jresult ;
31852   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31853   Dali::LongPressGestureDetector *arg2 = 0 ;
31854   Dali::LongPressGestureDetector *result = 0 ;
31855
31856   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31857   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31858   if (!arg2) {
31859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31860     return 0;
31861   }
31862   {
31863     try {
31864       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31865     } catch (std::out_of_range& e) {
31866       {
31867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31868       };
31869     } catch (std::exception& e) {
31870       {
31871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31872       };
31873     } catch (Dali::DaliException e) {
31874       {
31875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31876       };
31877     } catch (...) {
31878       {
31879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31880       };
31881     }
31882   }
31883
31884   jresult = (void *)result;
31885   return jresult;
31886 }
31887
31888
31889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31890   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31891   unsigned int arg2 ;
31892
31893   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31894   arg2 = (unsigned int)jarg2;
31895   {
31896     try {
31897       (arg1)->SetTouchesRequired(arg2);
31898     } catch (std::out_of_range& e) {
31899       {
31900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31901       };
31902     } catch (std::exception& e) {
31903       {
31904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31905       };
31906     } catch (Dali::DaliException e) {
31907       {
31908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31909       };
31910     } catch (...) {
31911       {
31912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31913       };
31914     }
31915   }
31916
31917 }
31918
31919
31920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31921   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31922   unsigned int arg2 ;
31923   unsigned int arg3 ;
31924
31925   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31926   arg2 = (unsigned int)jarg2;
31927   arg3 = (unsigned int)jarg3;
31928   {
31929     try {
31930       (arg1)->SetTouchesRequired(arg2,arg3);
31931     } catch (std::out_of_range& e) {
31932       {
31933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31934       };
31935     } catch (std::exception& e) {
31936       {
31937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31938       };
31939     } catch (Dali::DaliException e) {
31940       {
31941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31942       };
31943     } catch (...) {
31944       {
31945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31946       };
31947     }
31948   }
31949
31950 }
31951
31952
31953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31954   unsigned int jresult ;
31955   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31956   unsigned int result;
31957
31958   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31959   {
31960     try {
31961       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31962     } catch (std::out_of_range& e) {
31963       {
31964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31965       };
31966     } catch (std::exception& e) {
31967       {
31968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31969       };
31970     } catch (Dali::DaliException e) {
31971       {
31972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31973       };
31974     } catch (...) {
31975       {
31976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31977       };
31978     }
31979   }
31980
31981   jresult = result;
31982   return jresult;
31983 }
31984
31985
31986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31987   unsigned int jresult ;
31988   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31989   unsigned int result;
31990
31991   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31992   {
31993     try {
31994       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31995     } catch (std::out_of_range& e) {
31996       {
31997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31998       };
31999     } catch (std::exception& e) {
32000       {
32001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32002       };
32003     } catch (Dali::DaliException e) {
32004       {
32005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32006       };
32007     } catch (...) {
32008       {
32009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32010       };
32011     }
32012   }
32013
32014   jresult = result;
32015   return jresult;
32016 }
32017
32018
32019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
32020   void * jresult ;
32021   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
32022   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
32023
32024   arg1 = (Dali::LongPressGestureDetector *)jarg1;
32025   {
32026     try {
32027       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
32028     } catch (std::out_of_range& e) {
32029       {
32030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32031       };
32032     } catch (std::exception& e) {
32033       {
32034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32035       };
32036     } catch (Dali::DaliException e) {
32037       {
32038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32039       };
32040     } catch (...) {
32041       {
32042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32043       };
32044     }
32045   }
32046
32047   jresult = (void *)result;
32048   return jresult;
32049 }
32050
32051
32052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
32053   void * jresult ;
32054   Dali::Gesture::State arg1 ;
32055   Dali::LongPressGesture *result = 0 ;
32056
32057   arg1 = (Dali::Gesture::State)jarg1;
32058   {
32059     try {
32060       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
32061     } catch (std::out_of_range& e) {
32062       {
32063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32064       };
32065     } catch (std::exception& e) {
32066       {
32067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32068       };
32069     } catch (Dali::DaliException e) {
32070       {
32071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32072       };
32073     } catch (...) {
32074       {
32075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32076       };
32077     }
32078   }
32079
32080   jresult = (void *)result;
32081   return jresult;
32082 }
32083
32084
32085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32086   void * jresult ;
32087   Dali::LongPressGesture *arg1 = 0 ;
32088   Dali::LongPressGesture *result = 0 ;
32089
32090   arg1 = (Dali::LongPressGesture *)jarg1;
32091   if (!arg1) {
32092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32093     return 0;
32094   }
32095   {
32096     try {
32097       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32098     } catch (std::out_of_range& e) {
32099       {
32100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32101       };
32102     } catch (std::exception& e) {
32103       {
32104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32105       };
32106     } catch (Dali::DaliException e) {
32107       {
32108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32109       };
32110     } catch (...) {
32111       {
32112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32113       };
32114     }
32115   }
32116
32117   jresult = (void *)result;
32118   return jresult;
32119 }
32120
32121
32122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32123   void * jresult ;
32124   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32125   Dali::LongPressGesture *arg2 = 0 ;
32126   Dali::LongPressGesture *result = 0 ;
32127
32128   arg1 = (Dali::LongPressGesture *)jarg1;
32129   arg2 = (Dali::LongPressGesture *)jarg2;
32130   if (!arg2) {
32131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32132     return 0;
32133   }
32134   {
32135     try {
32136       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32137     } catch (std::out_of_range& e) {
32138       {
32139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32140       };
32141     } catch (std::exception& e) {
32142       {
32143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32144       };
32145     } catch (Dali::DaliException e) {
32146       {
32147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32148       };
32149     } catch (...) {
32150       {
32151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32152       };
32153     }
32154   }
32155
32156   jresult = (void *)result;
32157   return jresult;
32158 }
32159
32160
32161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32162   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32163
32164   arg1 = (Dali::LongPressGesture *)jarg1;
32165   {
32166     try {
32167       delete arg1;
32168     } catch (std::out_of_range& e) {
32169       {
32170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32171       };
32172     } catch (std::exception& e) {
32173       {
32174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32175       };
32176     } catch (Dali::DaliException e) {
32177       {
32178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32179       };
32180     } catch (...) {
32181       {
32182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32183       };
32184     }
32185   }
32186
32187 }
32188
32189
32190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32191   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32192   unsigned int arg2 ;
32193
32194   arg1 = (Dali::LongPressGesture *)jarg1;
32195   arg2 = (unsigned int)jarg2;
32196   if (arg1) (arg1)->numberOfTouches = arg2;
32197 }
32198
32199
32200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32201   unsigned int jresult ;
32202   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32203   unsigned int result;
32204
32205   arg1 = (Dali::LongPressGesture *)jarg1;
32206   result = (unsigned int) ((arg1)->numberOfTouches);
32207   jresult = result;
32208   return jresult;
32209 }
32210
32211
32212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32213   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32214   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32215
32216   arg1 = (Dali::LongPressGesture *)jarg1;
32217   arg2 = (Dali::Vector2 *)jarg2;
32218   if (arg1) (arg1)->screenPoint = *arg2;
32219 }
32220
32221
32222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32223   void * jresult ;
32224   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32225   Dali::Vector2 *result = 0 ;
32226
32227   arg1 = (Dali::LongPressGesture *)jarg1;
32228   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32229   jresult = (void *)result;
32230   return jresult;
32231 }
32232
32233
32234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32235   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32236   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32237
32238   arg1 = (Dali::LongPressGesture *)jarg1;
32239   arg2 = (Dali::Vector2 *)jarg2;
32240   if (arg1) (arg1)->localPoint = *arg2;
32241 }
32242
32243
32244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32245   void * jresult ;
32246   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32247   Dali::Vector2 *result = 0 ;
32248
32249   arg1 = (Dali::LongPressGesture *)jarg1;
32250   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32251   jresult = (void *)result;
32252   return jresult;
32253 }
32254
32255
32256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32257   void * jresult ;
32258   Dali::WheelEvent *result = 0 ;
32259
32260   {
32261     try {
32262       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32263     } catch (std::out_of_range& e) {
32264       {
32265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32266       };
32267     } catch (std::exception& e) {
32268       {
32269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32270       };
32271     } catch (Dali::DaliException e) {
32272       {
32273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32274       };
32275     } catch (...) {
32276       {
32277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32278       };
32279     }
32280   }
32281
32282   jresult = (void *)result;
32283   return jresult;
32284 }
32285
32286
32287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32288   void * jresult ;
32289   Dali::WheelEvent::Type arg1 ;
32290   int arg2 ;
32291   unsigned int arg3 ;
32292   Dali::Vector2 arg4 ;
32293   int arg5 ;
32294   unsigned int arg6 ;
32295   Dali::Vector2 *argp4 ;
32296   Dali::WheelEvent *result = 0 ;
32297
32298   arg1 = (Dali::WheelEvent::Type)jarg1;
32299   arg2 = (int)jarg2;
32300   arg3 = (unsigned int)jarg3;
32301   argp4 = (Dali::Vector2 *)jarg4;
32302   if (!argp4) {
32303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32304     return 0;
32305   }
32306   arg4 = *argp4;
32307   arg5 = (int)jarg5;
32308   arg6 = (unsigned int)jarg6;
32309   {
32310     try {
32311       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32312     } catch (std::out_of_range& e) {
32313       {
32314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32315       };
32316     } catch (std::exception& e) {
32317       {
32318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32319       };
32320     } catch (Dali::DaliException e) {
32321       {
32322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32323       };
32324     } catch (...) {
32325       {
32326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32327       };
32328     }
32329   }
32330
32331   jresult = (void *)result;
32332   return jresult;
32333 }
32334
32335
32336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32337   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32338
32339   arg1 = (Dali::WheelEvent *)jarg1;
32340   {
32341     try {
32342       delete arg1;
32343     } catch (std::out_of_range& e) {
32344       {
32345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32346       };
32347     } catch (std::exception& e) {
32348       {
32349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32350       };
32351     } catch (Dali::DaliException e) {
32352       {
32353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32354       };
32355     } catch (...) {
32356       {
32357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32358       };
32359     }
32360   }
32361
32362 }
32363
32364
32365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32366   unsigned int jresult ;
32367   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32368   bool result;
32369
32370   arg1 = (Dali::WheelEvent *)jarg1;
32371   {
32372     try {
32373       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32374     } catch (std::out_of_range& e) {
32375       {
32376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32377       };
32378     } catch (std::exception& e) {
32379       {
32380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32381       };
32382     } catch (Dali::DaliException e) {
32383       {
32384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32385       };
32386     } catch (...) {
32387       {
32388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32389       };
32390     }
32391   }
32392
32393   jresult = result;
32394   return jresult;
32395 }
32396
32397
32398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32399   unsigned int jresult ;
32400   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32401   bool result;
32402
32403   arg1 = (Dali::WheelEvent *)jarg1;
32404   {
32405     try {
32406       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32407     } catch (std::out_of_range& e) {
32408       {
32409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32410       };
32411     } catch (std::exception& e) {
32412       {
32413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32414       };
32415     } catch (Dali::DaliException e) {
32416       {
32417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32418       };
32419     } catch (...) {
32420       {
32421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32422       };
32423     }
32424   }
32425
32426   jresult = result;
32427   return jresult;
32428 }
32429
32430
32431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32432   unsigned int jresult ;
32433   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32434   bool result;
32435
32436   arg1 = (Dali::WheelEvent *)jarg1;
32437   {
32438     try {
32439       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32440     } catch (std::out_of_range& e) {
32441       {
32442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32443       };
32444     } catch (std::exception& e) {
32445       {
32446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32447       };
32448     } catch (Dali::DaliException e) {
32449       {
32450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32451       };
32452     } catch (...) {
32453       {
32454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32455       };
32456     }
32457   }
32458
32459   jresult = result;
32460   return jresult;
32461 }
32462
32463
32464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32465   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32466   Dali::WheelEvent::Type arg2 ;
32467
32468   arg1 = (Dali::WheelEvent *)jarg1;
32469   arg2 = (Dali::WheelEvent::Type)jarg2;
32470   if (arg1) (arg1)->type = arg2;
32471 }
32472
32473
32474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32475   int jresult ;
32476   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32477   Dali::WheelEvent::Type result;
32478
32479   arg1 = (Dali::WheelEvent *)jarg1;
32480   result = (Dali::WheelEvent::Type) ((arg1)->type);
32481   jresult = (int)result;
32482   return jresult;
32483 }
32484
32485
32486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32487   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32488   int arg2 ;
32489
32490   arg1 = (Dali::WheelEvent *)jarg1;
32491   arg2 = (int)jarg2;
32492   if (arg1) (arg1)->direction = arg2;
32493 }
32494
32495
32496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32497   int jresult ;
32498   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32499   int result;
32500
32501   arg1 = (Dali::WheelEvent *)jarg1;
32502   result = (int) ((arg1)->direction);
32503   jresult = result;
32504   return jresult;
32505 }
32506
32507
32508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32509   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32510   unsigned int arg2 ;
32511
32512   arg1 = (Dali::WheelEvent *)jarg1;
32513   arg2 = (unsigned int)jarg2;
32514   if (arg1) (arg1)->modifiers = arg2;
32515 }
32516
32517
32518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32519   unsigned int jresult ;
32520   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32521   unsigned int result;
32522
32523   arg1 = (Dali::WheelEvent *)jarg1;
32524   result = (unsigned int) ((arg1)->modifiers);
32525   jresult = result;
32526   return jresult;
32527 }
32528
32529
32530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32531   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32532   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32533
32534   arg1 = (Dali::WheelEvent *)jarg1;
32535   arg2 = (Dali::Vector2 *)jarg2;
32536   if (arg1) (arg1)->point = *arg2;
32537 }
32538
32539
32540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32541   void * jresult ;
32542   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32543   Dali::Vector2 *result = 0 ;
32544
32545   arg1 = (Dali::WheelEvent *)jarg1;
32546   result = (Dali::Vector2 *)& ((arg1)->point);
32547   jresult = (void *)result;
32548   return jresult;
32549 }
32550
32551
32552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32553   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32554   int arg2 ;
32555
32556   arg1 = (Dali::WheelEvent *)jarg1;
32557   arg2 = (int)jarg2;
32558   if (arg1) (arg1)->z = arg2;
32559 }
32560
32561
32562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32563   int jresult ;
32564   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32565   int result;
32566
32567   arg1 = (Dali::WheelEvent *)jarg1;
32568   result = (int) ((arg1)->z);
32569   jresult = result;
32570   return jresult;
32571 }
32572
32573
32574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32575   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32576   unsigned int arg2 ;
32577
32578   arg1 = (Dali::WheelEvent *)jarg1;
32579   arg2 = (unsigned int)jarg2;
32580   if (arg1) (arg1)->timeStamp = arg2;
32581 }
32582
32583
32584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32585   unsigned int jresult ;
32586   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32587   unsigned int result;
32588
32589   arg1 = (Dali::WheelEvent *)jarg1;
32590   result = (unsigned int) ((arg1)->timeStamp);
32591   jresult = result;
32592   return jresult;
32593 }
32594
32595 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32596   char * jresult ;
32597   Dali::KeyEvent *arg1 = 0 ;
32598   std::string result;
32599
32600   arg1 = (Dali::KeyEvent *)jarg1;
32601   if (!arg1) {
32602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32603     return 0;
32604   }
32605   {
32606     try {
32607       result = arg1->GetDeviceName();
32608     } catch (std::out_of_range& e) {
32609       {
32610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32611       };
32612     } catch (std::exception& e) {
32613       {
32614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32615       };
32616     } catch (Dali::DaliException e) {
32617       {
32618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32619       };
32620     } catch (...) {
32621       {
32622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32623       };
32624     }
32625   }
32626
32627   jresult = SWIG_csharp_string_callback((&result)->c_str());
32628   return jresult;
32629 }
32630
32631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32632   int jresult ;
32633   Dali::KeyEvent *arg1 = 0 ;
32634   Dali::Device::Class::Type result;
32635
32636   arg1 = (Dali::KeyEvent *)jarg1;
32637   if (!arg1) {
32638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32639     return 0;
32640   }
32641   {
32642     try {
32643       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32644     } catch (std::out_of_range& e) {
32645       {
32646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32647       };
32648     } catch (std::exception& e) {
32649       {
32650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32651       };
32652     } catch (Dali::DaliException e) {
32653       {
32654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32655       };
32656     } catch (...) {
32657       {
32658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32659       };
32660     }
32661   }
32662
32663   jresult = (int)result;
32664   return jresult;
32665 }
32666
32667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32668   int jresult ;
32669   Dali::KeyEvent *arg1 = 0 ;
32670   Dali::Device::Subclass::Type result;
32671
32672   arg1 = (Dali::KeyEvent *)jarg1;
32673   if (!arg1) {
32674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32675     return 0;
32676   }
32677   {
32678     try {
32679       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32680     } catch (std::out_of_range& e) {
32681       {
32682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32683       };
32684     } catch (std::exception& e) {
32685       {
32686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32687       };
32688     } catch (Dali::DaliException e) {
32689       {
32690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32691       };
32692     } catch (...) {
32693       {
32694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32695       };
32696     }
32697   }
32698
32699   jresult = (int)result;
32700   return jresult;
32701 }
32702
32703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32704   Dali::Actor arg1 ;
32705   Dali::Actor *argp1 ;
32706
32707   argp1 = (Dali::Actor *)jarg1;
32708   if (!argp1) {
32709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32710     return ;
32711   }
32712   arg1 = *argp1;
32713   {
32714     try {
32715       arg1.Raise();
32716     } catch (std::out_of_range& e) {
32717       {
32718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32719       };
32720     } catch (std::exception& e) {
32721       {
32722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32723       };
32724     } catch (Dali::DaliException e) {
32725       {
32726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32727       };
32728     } catch (...) {
32729       {
32730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32731       };
32732     }
32733   }
32734
32735 }
32736
32737
32738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32739   Dali::Actor arg1 ;
32740   Dali::Actor *argp1 ;
32741
32742   argp1 = (Dali::Actor *)jarg1;
32743   if (!argp1) {
32744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32745     return ;
32746   }
32747   arg1 = *argp1;
32748   {
32749     try {
32750       arg1.Lower();
32751     } catch (std::out_of_range& e) {
32752       {
32753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32754       };
32755     } catch (std::exception& e) {
32756       {
32757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32758       };
32759     } catch (Dali::DaliException e) {
32760       {
32761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32762       };
32763     } catch (...) {
32764       {
32765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32766       };
32767     }
32768   }
32769
32770 }
32771
32772
32773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32774   Dali::Actor arg1 ;
32775   Dali::Actor *argp1 ;
32776
32777   argp1 = (Dali::Actor *)jarg1;
32778   if (!argp1) {
32779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32780     return ;
32781   }
32782   arg1 = *argp1;
32783   {
32784     try {
32785       arg1.RaiseToTop();
32786     } catch (std::out_of_range& e) {
32787       {
32788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32789       };
32790     } catch (std::exception& e) {
32791       {
32792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32793       };
32794     } catch (Dali::DaliException e) {
32795       {
32796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32797       };
32798     } catch (...) {
32799       {
32800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32801       };
32802     }
32803   }
32804
32805 }
32806
32807
32808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32809   Dali::Actor arg1 ;
32810   Dali::Actor *argp1 ;
32811
32812   argp1 = (Dali::Actor *)jarg1;
32813   if (!argp1) {
32814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32815     return ;
32816   }
32817   arg1 = *argp1;
32818   {
32819     try {
32820       arg1.LowerToBottom();
32821     } catch (std::out_of_range& e) {
32822       {
32823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32824       };
32825     } catch (std::exception& e) {
32826       {
32827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32828       };
32829     } catch (Dali::DaliException e) {
32830       {
32831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32832       };
32833     } catch (...) {
32834       {
32835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32836       };
32837     }
32838   }
32839
32840 }
32841
32842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32843   Dali::Actor arg1 ;
32844   Dali::Actor arg2 ;
32845   Dali::Actor *argp1 ;
32846   Dali::Actor *argp2 ;
32847
32848   argp1 = (Dali::Actor *)jarg1;
32849   if (!argp1) {
32850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32851     return ;
32852   }
32853   arg1 = *argp1;
32854   argp2 = (Dali::Actor *)jarg2;
32855   if (!argp2) {
32856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32857     return ;
32858   }
32859   arg2 = *argp2;
32860   {
32861     try {
32862       arg1.RaiseAbove(arg2);
32863     } catch (std::out_of_range& e) {
32864       {
32865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32866       };
32867     } catch (std::exception& e) {
32868       {
32869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32870       };
32871     } catch (Dali::DaliException e) {
32872       {
32873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32874       };
32875     } catch (...) {
32876       {
32877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32878       };
32879     }
32880   }
32881
32882 }
32883
32884
32885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32886   Dali::Actor arg1 ;
32887   Dali::Actor arg2 ;
32888   Dali::Actor *argp1 ;
32889   Dali::Actor *argp2 ;
32890
32891   argp1 = (Dali::Actor *)jarg1;
32892   if (!argp1) {
32893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32894     return ;
32895   }
32896   arg1 = *argp1;
32897   argp2 = (Dali::Actor *)jarg2;
32898   if (!argp2) {
32899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32900     return ;
32901   }
32902   arg2 = *argp2;
32903   {
32904     try {
32905       arg1.LowerBelow(arg2);
32906     } catch (std::out_of_range& e) {
32907       {
32908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32909       };
32910     } catch (std::exception& e) {
32911       {
32912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32913       };
32914     } catch (Dali::DaliException e) {
32915       {
32916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32917       };
32918     } catch (...) {
32919       {
32920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32921       };
32922     }
32923   }
32924
32925 }
32926
32927
32928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32929   void * jresult ;
32930   Dali::Actor arg1 ;
32931   Dali::Actor *argp1 ;
32932   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32933
32934   argp1 = (Dali::Actor *)jarg1;
32935   if (!argp1) {
32936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32937     return 0;
32938   }
32939   arg1 = *argp1;
32940   {
32941     try {
32942       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32943     } catch (std::out_of_range& e) {
32944       {
32945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32946       };
32947     } catch (std::exception& e) {
32948       {
32949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32950       };
32951     } catch (Dali::DaliException e) {
32952       {
32953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32954       };
32955     } catch (...) {
32956       {
32957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32958       };
32959     }
32960   }
32961
32962   jresult = (void *)result;
32963   return jresult;
32964 }
32965
32966
32967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32968   void * jresult ;
32969   Dali::Actor *arg1 ;
32970   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32971
32972   arg1 = (Dali::Actor *)jarg1;
32973   {
32974     try {
32975       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32976     } catch (std::out_of_range& e) {
32977       {
32978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32979       };
32980     } catch (std::exception& e) {
32981       {
32982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32983       };
32984     } catch (Dali::DaliException e) {
32985       {
32986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32987       };
32988     } catch (...) {
32989       {
32990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32991       };
32992     }
32993   }
32994
32995   jresult = (void *)result;
32996   return jresult;
32997 }
32998
32999
33000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
33001   int jresult ;
33002   int result;
33003
33004   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
33005   jresult = (int)result;
33006   return jresult;
33007 }
33008
33009
33010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
33011   int jresult ;
33012   int result;
33013
33014   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
33015   jresult = (int)result;
33016   return jresult;
33017 }
33018
33019
33020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
33021   int jresult ;
33022   int result;
33023
33024   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
33025   jresult = (int)result;
33026   return jresult;
33027 }
33028
33029
33030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
33031   int jresult ;
33032   int result;
33033
33034   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
33035   jresult = (int)result;
33036   return jresult;
33037 }
33038
33039
33040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
33041   int jresult ;
33042   int result;
33043
33044   result = (int)Dali::Actor::Property::ANCHOR_POINT;
33045   jresult = (int)result;
33046   return jresult;
33047 }
33048
33049
33050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
33051   int jresult ;
33052   int result;
33053
33054   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
33055   jresult = (int)result;
33056   return jresult;
33057 }
33058
33059
33060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
33061   int jresult ;
33062   int result;
33063
33064   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
33065   jresult = (int)result;
33066   return jresult;
33067 }
33068
33069
33070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33071   int jresult ;
33072   int result;
33073
33074   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33075   jresult = (int)result;
33076   return jresult;
33077 }
33078
33079
33080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33081   int jresult ;
33082   int result;
33083
33084   result = (int)Dali::Actor::Property::SIZE;
33085   jresult = (int)result;
33086   return jresult;
33087 }
33088
33089
33090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33091   int jresult ;
33092   int result;
33093
33094   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33095   jresult = (int)result;
33096   return jresult;
33097 }
33098
33099
33100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33101   int jresult ;
33102   int result;
33103
33104   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33105   jresult = (int)result;
33106   return jresult;
33107 }
33108
33109
33110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33111   int jresult ;
33112   int result;
33113
33114   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33115   jresult = (int)result;
33116   return jresult;
33117 }
33118
33119
33120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33121   int jresult ;
33122   int result;
33123
33124   result = (int)Dali::Actor::Property::POSITION;
33125   jresult = (int)result;
33126   return jresult;
33127 }
33128
33129
33130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33131   int jresult ;
33132   int result;
33133
33134   result = (int)Dali::Actor::Property::POSITION_X;
33135   jresult = (int)result;
33136   return jresult;
33137 }
33138
33139
33140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33141   int jresult ;
33142   int result;
33143
33144   result = (int)Dali::Actor::Property::POSITION_Y;
33145   jresult = (int)result;
33146   return jresult;
33147 }
33148
33149
33150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33151   int jresult ;
33152   int result;
33153
33154   result = (int)Dali::Actor::Property::POSITION_Z;
33155   jresult = (int)result;
33156   return jresult;
33157 }
33158
33159
33160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33161   int jresult ;
33162   int result;
33163
33164   result = (int)Dali::Actor::Property::WORLD_POSITION;
33165   jresult = (int)result;
33166   return jresult;
33167 }
33168
33169
33170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33171   int jresult ;
33172   int result;
33173
33174   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33175   jresult = (int)result;
33176   return jresult;
33177 }
33178
33179
33180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33181   int jresult ;
33182   int result;
33183
33184   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33185   jresult = (int)result;
33186   return jresult;
33187 }
33188
33189
33190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33191   int jresult ;
33192   int result;
33193
33194   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33195   jresult = (int)result;
33196   return jresult;
33197 }
33198
33199
33200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33201   int jresult ;
33202   int result;
33203
33204   result = (int)Dali::Actor::Property::ORIENTATION;
33205   jresult = (int)result;
33206   return jresult;
33207 }
33208
33209
33210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33211   int jresult ;
33212   int result;
33213
33214   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33215   jresult = (int)result;
33216   return jresult;
33217 }
33218
33219
33220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33221   int jresult ;
33222   int result;
33223
33224   result = (int)Dali::Actor::Property::SCALE;
33225   jresult = (int)result;
33226   return jresult;
33227 }
33228
33229
33230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33231   int jresult ;
33232   int result;
33233
33234   result = (int)Dali::Actor::Property::SCALE_X;
33235   jresult = (int)result;
33236   return jresult;
33237 }
33238
33239
33240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33241   int jresult ;
33242   int result;
33243
33244   result = (int)Dali::Actor::Property::SCALE_Y;
33245   jresult = (int)result;
33246   return jresult;
33247 }
33248
33249
33250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33251   int jresult ;
33252   int result;
33253
33254   result = (int)Dali::Actor::Property::SCALE_Z;
33255   jresult = (int)result;
33256   return jresult;
33257 }
33258
33259
33260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33261   int jresult ;
33262   int result;
33263
33264   result = (int)Dali::Actor::Property::WORLD_SCALE;
33265   jresult = (int)result;
33266   return jresult;
33267 }
33268
33269
33270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33271   int jresult ;
33272   int result;
33273
33274   result = (int)Dali::Actor::Property::VISIBLE;
33275   jresult = (int)result;
33276   return jresult;
33277 }
33278
33279
33280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33281   int jresult ;
33282   int result;
33283
33284   result = (int)Dali::Actor::Property::COLOR;
33285   jresult = (int)result;
33286   return jresult;
33287 }
33288
33289
33290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33291   int jresult ;
33292   int result;
33293
33294   result = (int)Dali::Actor::Property::COLOR_RED;
33295   jresult = (int)result;
33296   return jresult;
33297 }
33298
33299
33300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33301   int jresult ;
33302   int result;
33303
33304   result = (int)Dali::Actor::Property::COLOR_GREEN;
33305   jresult = (int)result;
33306   return jresult;
33307 }
33308
33309
33310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33311   int jresult ;
33312   int result;
33313
33314   result = (int)Dali::Actor::Property::COLOR_BLUE;
33315   jresult = (int)result;
33316   return jresult;
33317 }
33318
33319
33320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33321   int jresult ;
33322   int result;
33323
33324   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33325   jresult = (int)result;
33326   return jresult;
33327 }
33328
33329
33330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33331   int jresult ;
33332   int result;
33333
33334   result = (int)Dali::Actor::Property::WORLD_COLOR;
33335   jresult = (int)result;
33336   return jresult;
33337 }
33338
33339
33340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33341   int jresult ;
33342   int result;
33343
33344   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33345   jresult = (int)result;
33346   return jresult;
33347 }
33348
33349
33350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33351   int jresult ;
33352   int result;
33353
33354   result = (int)Dali::Actor::Property::NAME;
33355   jresult = (int)result;
33356   return jresult;
33357 }
33358
33359
33360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33361   int jresult ;
33362   int result;
33363
33364   result = (int)Dali::Actor::Property::SENSITIVE;
33365   jresult = (int)result;
33366   return jresult;
33367 }
33368
33369
33370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33371   int jresult ;
33372   int result;
33373
33374   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33375   jresult = (int)result;
33376   return jresult;
33377 }
33378
33379
33380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33381   int jresult ;
33382   int result;
33383
33384   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33385   jresult = (int)result;
33386   return jresult;
33387 }
33388
33389
33390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33391   int jresult ;
33392   int result;
33393
33394   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33395   jresult = (int)result;
33396   return jresult;
33397 }
33398
33399
33400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33401   int jresult ;
33402   int result;
33403
33404   result = (int)Dali::Actor::Property::COLOR_MODE;
33405   jresult = (int)result;
33406   return jresult;
33407 }
33408
33409
33410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33411   int jresult ;
33412   int result;
33413
33414   result = (int)Dali::Actor::Property::DRAW_MODE;
33415   jresult = (int)result;
33416   return jresult;
33417 }
33418
33419
33420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33421   int jresult ;
33422   int result;
33423
33424   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33425   jresult = (int)result;
33426   return jresult;
33427 }
33428
33429
33430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33431   int jresult ;
33432   int result;
33433
33434   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33435   jresult = (int)result;
33436   return jresult;
33437 }
33438
33439
33440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33441   int jresult ;
33442   int result;
33443
33444   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33445   jresult = (int)result;
33446   return jresult;
33447 }
33448
33449
33450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33451   int jresult ;
33452   int result;
33453
33454   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33455   jresult = (int)result;
33456   return jresult;
33457 }
33458
33459
33460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33461   int jresult ;
33462   int result;
33463
33464   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33465   jresult = (int)result;
33466   return jresult;
33467 }
33468
33469
33470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33471   int jresult ;
33472   int result;
33473
33474   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33475   jresult = (int)result;
33476   return jresult;
33477 }
33478
33479
33480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33481   int jresult ;
33482   int result;
33483
33484   result = (int)Dali::Actor::Property::PADDING;
33485   jresult = (int)result;
33486   return jresult;
33487 }
33488
33489
33490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33491   int jresult ;
33492   int result;
33493
33494   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33495   jresult = (int)result;
33496   return jresult;
33497 }
33498
33499
33500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33501   int jresult ;
33502   int result;
33503
33504   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33505   jresult = (int)result;
33506   return jresult;
33507 }
33508
33509
33510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33511   int jresult ;
33512   int result;
33513
33514   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33515   jresult = (int)result;
33516   return jresult;
33517 }
33518
33519
33520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33521   int jresult ;
33522   int result;
33523
33524   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33525   jresult = (int)result;
33526   return jresult;
33527 }
33528
33529
33530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33531   void * jresult ;
33532   Dali::Actor::Property *result = 0 ;
33533
33534   {
33535     try {
33536       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33537     } catch (std::out_of_range& e) {
33538       {
33539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33540       };
33541     } catch (std::exception& e) {
33542       {
33543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33544       };
33545     } catch (Dali::DaliException e) {
33546       {
33547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33548       };
33549     } catch (...) {
33550       {
33551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33552       };
33553     }
33554   }
33555
33556   jresult = (void *)result;
33557   return jresult;
33558 }
33559
33560
33561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33562   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33563
33564   arg1 = (Dali::Actor::Property *)jarg1;
33565   {
33566     try {
33567       delete arg1;
33568     } catch (std::out_of_range& e) {
33569       {
33570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33571       };
33572     } catch (std::exception& e) {
33573       {
33574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33575       };
33576     } catch (Dali::DaliException e) {
33577       {
33578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33579       };
33580     } catch (...) {
33581       {
33582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33583       };
33584     }
33585   }
33586
33587 }
33588
33589
33590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33591   void * jresult ;
33592   Dali::Actor *result = 0 ;
33593
33594   {
33595     try {
33596       result = (Dali::Actor *)new Dali::Actor();
33597     } catch (std::out_of_range& e) {
33598       {
33599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33600       };
33601     } catch (std::exception& e) {
33602       {
33603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33604       };
33605     } catch (Dali::DaliException e) {
33606       {
33607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33608       };
33609     } catch (...) {
33610       {
33611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33612       };
33613     }
33614   }
33615
33616   jresult = (void *)result;
33617   return jresult;
33618 }
33619
33620
33621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33622   void * jresult ;
33623   Dali::Actor result;
33624
33625   {
33626     try {
33627       result = Dali::Actor::New();
33628     } catch (std::out_of_range& e) {
33629       {
33630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33631       };
33632     } catch (std::exception& e) {
33633       {
33634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33635       };
33636     } catch (Dali::DaliException e) {
33637       {
33638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33639       };
33640     } catch (...) {
33641       {
33642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33643       };
33644     }
33645   }
33646
33647   jresult = new Dali::Actor((const Dali::Actor &)result);
33648   return jresult;
33649 }
33650
33651
33652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33653   void * jresult ;
33654   Dali::BaseHandle arg1 ;
33655   Dali::BaseHandle *argp1 ;
33656   Dali::Actor result;
33657
33658   argp1 = (Dali::BaseHandle *)jarg1;
33659   if (!argp1) {
33660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33661     return 0;
33662   }
33663   arg1 = *argp1;
33664   {
33665     try {
33666       result = Dali::Actor::DownCast(arg1);
33667     } catch (std::out_of_range& e) {
33668       {
33669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33670       };
33671     } catch (std::exception& e) {
33672       {
33673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33674       };
33675     } catch (Dali::DaliException e) {
33676       {
33677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33678       };
33679     } catch (...) {
33680       {
33681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33682       };
33683     }
33684   }
33685
33686   jresult = new Dali::Actor((const Dali::Actor &)result);
33687   return jresult;
33688 }
33689
33690
33691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33692   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33693
33694   arg1 = (Dali::Actor *)jarg1;
33695   {
33696     try {
33697       delete arg1;
33698     } catch (std::out_of_range& e) {
33699       {
33700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33701       };
33702     } catch (std::exception& e) {
33703       {
33704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33705       };
33706     } catch (Dali::DaliException e) {
33707       {
33708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33709       };
33710     } catch (...) {
33711       {
33712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33713       };
33714     }
33715   }
33716
33717 }
33718
33719
33720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33721   void * jresult ;
33722   Dali::Actor *arg1 = 0 ;
33723   Dali::Actor *result = 0 ;
33724
33725   arg1 = (Dali::Actor *)jarg1;
33726   if (!arg1) {
33727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33728     return 0;
33729   }
33730   {
33731     try {
33732       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33733     } catch (std::out_of_range& e) {
33734       {
33735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33736       };
33737     } catch (std::exception& e) {
33738       {
33739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33740       };
33741     } catch (Dali::DaliException e) {
33742       {
33743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33744       };
33745     } catch (...) {
33746       {
33747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33748       };
33749     }
33750   }
33751
33752   jresult = (void *)result;
33753   return jresult;
33754 }
33755
33756
33757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33758   void * jresult ;
33759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33760   Dali::Actor *arg2 = 0 ;
33761   Dali::Actor *result = 0 ;
33762
33763   arg1 = (Dali::Actor *)jarg1;
33764   arg2 = (Dali::Actor *)jarg2;
33765   if (!arg2) {
33766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33767     return 0;
33768   }
33769   {
33770     try {
33771       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33772     } catch (std::out_of_range& e) {
33773       {
33774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33775       };
33776     } catch (std::exception& e) {
33777       {
33778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33779       };
33780     } catch (Dali::DaliException e) {
33781       {
33782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33783       };
33784     } catch (...) {
33785       {
33786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33787       };
33788     }
33789   }
33790
33791   jresult = (void *)result;
33792   return jresult;
33793 }
33794
33795
33796 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33797   char * jresult ;
33798   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33799   std::string *result = 0 ;
33800
33801   arg1 = (Dali::Actor *)jarg1;
33802   {
33803     try {
33804       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33805     } catch (std::out_of_range& e) {
33806       {
33807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33808       };
33809     } catch (std::exception& e) {
33810       {
33811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33812       };
33813     } catch (Dali::DaliException e) {
33814       {
33815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33816       };
33817     } catch (...) {
33818       {
33819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33820       };
33821     }
33822   }
33823
33824   jresult = SWIG_csharp_string_callback(result->c_str());
33825   return jresult;
33826 }
33827
33828
33829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33830   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33831   std::string *arg2 = 0 ;
33832
33833   arg1 = (Dali::Actor *)jarg1;
33834   if (!jarg2) {
33835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33836     return ;
33837   }
33838   std::string arg2_str(jarg2);
33839   arg2 = &arg2_str;
33840   {
33841     try {
33842       (arg1)->SetName((std::string const &)*arg2);
33843     } catch (std::out_of_range& e) {
33844       {
33845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33846       };
33847     } catch (std::exception& e) {
33848       {
33849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33850       };
33851     } catch (Dali::DaliException e) {
33852       {
33853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33854       };
33855     } catch (...) {
33856       {
33857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33858       };
33859     }
33860   }
33861
33862
33863   //argout typemap for const std::string&
33864
33865 }
33866
33867
33868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33869   unsigned int jresult ;
33870   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33871   unsigned int result;
33872
33873   arg1 = (Dali::Actor *)jarg1;
33874
33875   if(!arg1) {
33876     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33877     return -1;
33878   }
33879
33880   {
33881     try {
33882       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33883     } catch (std::out_of_range& e) {
33884       {
33885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33886       };
33887     } catch (std::exception& e) {
33888       {
33889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33890       };
33891     } catch (Dali::DaliException e) {
33892       {
33893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33894       };
33895     } catch (...) {
33896       {
33897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33898       };
33899     }
33900   }
33901
33902   jresult = result;
33903   return jresult;
33904 }
33905
33906
33907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33908   unsigned int jresult ;
33909   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33910   bool result;
33911
33912   arg1 = (Dali::Actor *)jarg1;
33913   {
33914     try {
33915       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33916     } catch (std::out_of_range& e) {
33917       {
33918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33919       };
33920     } catch (std::exception& e) {
33921       {
33922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33923       };
33924     } catch (Dali::DaliException e) {
33925       {
33926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33927       };
33928     } catch (...) {
33929       {
33930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33931       };
33932     }
33933   }
33934
33935   jresult = result;
33936   return jresult;
33937 }
33938
33939
33940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33941   unsigned int jresult ;
33942   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33943   bool result;
33944
33945   arg1 = (Dali::Actor *)jarg1;
33946   {
33947     try {
33948       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33949     } catch (std::out_of_range& e) {
33950       {
33951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33952       };
33953     } catch (std::exception& e) {
33954       {
33955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33956       };
33957     } catch (Dali::DaliException e) {
33958       {
33959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33960       };
33961     } catch (...) {
33962       {
33963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33964       };
33965     }
33966   }
33967
33968   jresult = result;
33969   return jresult;
33970 }
33971
33972
33973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33974   unsigned int jresult ;
33975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33976   bool result;
33977
33978   arg1 = (Dali::Actor *)jarg1;
33979   {
33980     try {
33981       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33982     } catch (std::out_of_range& e) {
33983       {
33984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33985       };
33986     } catch (std::exception& e) {
33987       {
33988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33989       };
33990     } catch (Dali::DaliException e) {
33991       {
33992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33993       };
33994     } catch (...) {
33995       {
33996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33997       };
33998     }
33999   }
34000
34001   jresult = result;
34002   return jresult;
34003 }
34004
34005
34006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
34007   void * jresult ;
34008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34009   Dali::Layer result;
34010
34011   arg1 = (Dali::Actor *)jarg1;
34012   {
34013     try {
34014       result = (arg1)->GetLayer();
34015     } catch (std::out_of_range& e) {
34016       {
34017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34018       };
34019     } catch (std::exception& e) {
34020       {
34021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34022       };
34023     } catch (Dali::DaliException e) {
34024       {
34025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34026       };
34027     } catch (...) {
34028       {
34029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34030       };
34031     }
34032   }
34033
34034   jresult = new Dali::Layer((const Dali::Layer &)result);
34035   return jresult;
34036 }
34037
34038
34039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
34040   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34041   Dali::Actor arg2 ;
34042   Dali::Actor *argp2 ;
34043
34044   arg1 = (Dali::Actor *)jarg1;
34045   argp2 = (Dali::Actor *)jarg2;
34046   if (!argp2) {
34047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34048     return ;
34049   }
34050   arg2 = *argp2;
34051   {
34052     try {
34053       (arg1)->Add(arg2);
34054     } catch (std::out_of_range& e) {
34055       {
34056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34057       };
34058     } catch (std::exception& e) {
34059       {
34060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34061       };
34062     } catch (Dali::DaliException e) {
34063       {
34064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34065       };
34066     } catch (...) {
34067       {
34068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34069       };
34070     }
34071   }
34072
34073 }
34074
34075
34076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34077   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34078   Dali::Actor arg2 ;
34079   Dali::Actor *argp2 ;
34080
34081   arg1 = (Dali::Actor *)jarg1;
34082   argp2 = (Dali::Actor *)jarg2;
34083   if (!argp2) {
34084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34085     return ;
34086   }
34087   arg2 = *argp2;
34088   {
34089     try {
34090       (arg1)->Remove(arg2);
34091     } catch (std::out_of_range& e) {
34092       {
34093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34094       };
34095     } catch (std::exception& e) {
34096       {
34097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34098       };
34099     } catch (Dali::DaliException e) {
34100       {
34101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34102       };
34103     } catch (...) {
34104       {
34105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34106       };
34107     }
34108   }
34109
34110 }
34111
34112
34113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34115
34116   arg1 = (Dali::Actor *)jarg1;
34117   {
34118     try {
34119       (arg1)->Unparent();
34120     } catch (std::out_of_range& e) {
34121       {
34122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34123       };
34124     } catch (std::exception& e) {
34125       {
34126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34127       };
34128     } catch (Dali::DaliException e) {
34129       {
34130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34131       };
34132     } catch (...) {
34133       {
34134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34135       };
34136     }
34137   }
34138
34139 }
34140
34141
34142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34143   unsigned int jresult ;
34144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34145   unsigned int result;
34146
34147   arg1 = (Dali::Actor *)jarg1;
34148   {
34149     try {
34150       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34151     } catch (std::out_of_range& e) {
34152       {
34153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34154       };
34155     } catch (std::exception& e) {
34156       {
34157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34158       };
34159     } catch (Dali::DaliException e) {
34160       {
34161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34162       };
34163     } catch (...) {
34164       {
34165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34166       };
34167     }
34168   }
34169
34170   jresult = result;
34171   return jresult;
34172 }
34173
34174
34175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34176   void * jresult ;
34177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34178   unsigned int arg2 ;
34179   Dali::Actor result;
34180
34181   arg1 = (Dali::Actor *)jarg1;
34182   arg2 = (unsigned int)jarg2;
34183   {
34184     try {
34185       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34186     } catch (std::out_of_range& e) {
34187       {
34188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34189       };
34190     } catch (std::exception& e) {
34191       {
34192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34193       };
34194     } catch (Dali::DaliException e) {
34195       {
34196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34197       };
34198     } catch (...) {
34199       {
34200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34201       };
34202     }
34203   }
34204
34205   jresult = new Dali::Actor((const Dali::Actor &)result);
34206   return jresult;
34207 }
34208
34209
34210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34211   void * jresult ;
34212   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34213   std::string *arg2 = 0 ;
34214   Dali::Actor result;
34215
34216   arg1 = (Dali::Actor *)jarg1;
34217   if (!jarg2) {
34218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34219     return 0;
34220   }
34221   std::string arg2_str(jarg2);
34222   arg2 = &arg2_str;
34223   {
34224     try {
34225       result = (arg1)->FindChildByName((std::string const &)*arg2);
34226     } catch (std::out_of_range& e) {
34227       {
34228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34229       };
34230     } catch (std::exception& e) {
34231       {
34232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34233       };
34234     } catch (Dali::DaliException e) {
34235       {
34236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34237       };
34238     } catch (...) {
34239       {
34240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34241       };
34242     }
34243   }
34244
34245   jresult = new Dali::Actor((const Dali::Actor &)result);
34246
34247   //argout typemap for const std::string&
34248
34249   return jresult;
34250 }
34251
34252
34253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34254   void * jresult ;
34255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34256   unsigned int arg2 ;
34257   Dali::Actor result;
34258
34259   arg1 = (Dali::Actor *)jarg1;
34260   arg2 = (unsigned int)jarg2;
34261   {
34262     try {
34263       result = (arg1)->FindChildById(arg2);
34264     } catch (std::out_of_range& e) {
34265       {
34266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34267       };
34268     } catch (std::exception& e) {
34269       {
34270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34271       };
34272     } catch (Dali::DaliException e) {
34273       {
34274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34275       };
34276     } catch (...) {
34277       {
34278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34279       };
34280     }
34281   }
34282
34283   jresult = new Dali::Actor((const Dali::Actor &)result);
34284   return jresult;
34285 }
34286
34287
34288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34289   void * jresult ;
34290   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34291   Dali::Actor result;
34292
34293   arg1 = (Dali::Actor *)jarg1;
34294   {
34295     try {
34296       result = ((Dali::Actor const *)arg1)->GetParent();
34297     } catch (std::out_of_range& e) {
34298       {
34299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34300       };
34301     } catch (std::exception& e) {
34302       {
34303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34304       };
34305     } catch (Dali::DaliException e) {
34306       {
34307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34308       };
34309     } catch (...) {
34310       {
34311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34312       };
34313     }
34314   }
34315
34316   jresult = new Dali::Actor((const Dali::Actor &)result);
34317   return jresult;
34318 }
34319
34320
34321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34322   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34323   Dali::Vector3 *arg2 = 0 ;
34324
34325   arg1 = (Dali::Actor *)jarg1;
34326   arg2 = (Dali::Vector3 *)jarg2;
34327   if (!arg2) {
34328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34329     return ;
34330   }
34331   {
34332     try {
34333       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34334     } catch (std::out_of_range& e) {
34335       {
34336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34337       };
34338     } catch (std::exception& e) {
34339       {
34340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34341       };
34342     } catch (Dali::DaliException e) {
34343       {
34344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34345       };
34346     } catch (...) {
34347       {
34348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34349       };
34350     }
34351   }
34352
34353 }
34354
34355
34356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34357   void * jresult ;
34358   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34359   Dali::Vector3 result;
34360
34361   arg1 = (Dali::Actor *)jarg1;
34362   {
34363     try {
34364       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34365     } catch (std::out_of_range& e) {
34366       {
34367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34368       };
34369     } catch (std::exception& e) {
34370       {
34371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34372       };
34373     } catch (Dali::DaliException e) {
34374       {
34375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34376       };
34377     } catch (...) {
34378       {
34379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34380       };
34381     }
34382   }
34383
34384   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34385   return jresult;
34386 }
34387
34388
34389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34391   Dali::Vector3 *arg2 = 0 ;
34392
34393   arg1 = (Dali::Actor *)jarg1;
34394   arg2 = (Dali::Vector3 *)jarg2;
34395   if (!arg2) {
34396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34397     return ;
34398   }
34399   {
34400     try {
34401       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34402     } catch (std::out_of_range& e) {
34403       {
34404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34405       };
34406     } catch (std::exception& e) {
34407       {
34408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34409       };
34410     } catch (Dali::DaliException e) {
34411       {
34412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34413       };
34414     } catch (...) {
34415       {
34416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34417       };
34418     }
34419   }
34420
34421 }
34422
34423
34424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34425   void * jresult ;
34426   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34427   Dali::Vector3 result;
34428
34429   arg1 = (Dali::Actor *)jarg1;
34430   {
34431     try {
34432       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34433     } catch (std::out_of_range& e) {
34434       {
34435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34436       };
34437     } catch (std::exception& e) {
34438       {
34439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34440       };
34441     } catch (Dali::DaliException e) {
34442       {
34443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34444       };
34445     } catch (...) {
34446       {
34447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34448       };
34449     }
34450   }
34451
34452   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34453   return jresult;
34454 }
34455
34456
34457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34458   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34459   float arg2 ;
34460   float arg3 ;
34461
34462   arg1 = (Dali::Actor *)jarg1;
34463   arg2 = (float)jarg2;
34464   arg3 = (float)jarg3;
34465   {
34466     try {
34467       (arg1)->SetSize(arg2,arg3);
34468     } catch (std::out_of_range& e) {
34469       {
34470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34471       };
34472     } catch (std::exception& e) {
34473       {
34474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34475       };
34476     } catch (Dali::DaliException e) {
34477       {
34478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34479       };
34480     } catch (...) {
34481       {
34482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34483       };
34484     }
34485   }
34486
34487 }
34488
34489
34490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34491   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34492   float arg2 ;
34493   float arg3 ;
34494   float arg4 ;
34495
34496   arg1 = (Dali::Actor *)jarg1;
34497   arg2 = (float)jarg2;
34498   arg3 = (float)jarg3;
34499   arg4 = (float)jarg4;
34500   {
34501     try {
34502       (arg1)->SetSize(arg2,arg3,arg4);
34503     } catch (std::out_of_range& e) {
34504       {
34505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34506       };
34507     } catch (std::exception& e) {
34508       {
34509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34510       };
34511     } catch (Dali::DaliException e) {
34512       {
34513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34514       };
34515     } catch (...) {
34516       {
34517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34518       };
34519     }
34520   }
34521
34522 }
34523
34524
34525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34526   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34527   Dali::Vector2 *arg2 = 0 ;
34528
34529   arg1 = (Dali::Actor *)jarg1;
34530   arg2 = (Dali::Vector2 *)jarg2;
34531   if (!arg2) {
34532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34533     return ;
34534   }
34535   {
34536     try {
34537       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34538     } catch (std::out_of_range& e) {
34539       {
34540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34541       };
34542     } catch (std::exception& e) {
34543       {
34544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34545       };
34546     } catch (Dali::DaliException e) {
34547       {
34548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34549       };
34550     } catch (...) {
34551       {
34552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34553       };
34554     }
34555   }
34556
34557 }
34558
34559
34560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34562   Dali::Vector3 *arg2 = 0 ;
34563
34564   arg1 = (Dali::Actor *)jarg1;
34565   arg2 = (Dali::Vector3 *)jarg2;
34566   if (!arg2) {
34567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34568     return ;
34569   }
34570   {
34571     try {
34572       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34573     } catch (std::out_of_range& e) {
34574       {
34575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34576       };
34577     } catch (std::exception& e) {
34578       {
34579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34580       };
34581     } catch (Dali::DaliException e) {
34582       {
34583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34584       };
34585     } catch (...) {
34586       {
34587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34588       };
34589     }
34590   }
34591
34592 }
34593
34594
34595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34596   void * jresult ;
34597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34598   Dali::Vector3 result;
34599
34600   arg1 = (Dali::Actor *)jarg1;
34601   {
34602     try {
34603       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34604     } catch (std::out_of_range& e) {
34605       {
34606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34607       };
34608     } catch (std::exception& e) {
34609       {
34610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34611       };
34612     } catch (Dali::DaliException e) {
34613       {
34614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34615       };
34616     } catch (...) {
34617       {
34618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34619       };
34620     }
34621   }
34622
34623   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34624   return jresult;
34625 }
34626
34627
34628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34629   void * jresult ;
34630   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34631   Dali::Vector3 result;
34632
34633   arg1 = (Dali::Actor *)jarg1;
34634   {
34635     try {
34636       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34637     } catch (std::out_of_range& e) {
34638       {
34639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34640       };
34641     } catch (std::exception& e) {
34642       {
34643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34644       };
34645     } catch (Dali::DaliException e) {
34646       {
34647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34648       };
34649     } catch (...) {
34650       {
34651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34652       };
34653     }
34654   }
34655
34656   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34657   return jresult;
34658 }
34659
34660
34661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34662   void * jresult ;
34663   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34664   Dali::Vector3 result;
34665
34666   arg1 = (Dali::Actor *)jarg1;
34667   {
34668     try {
34669       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34670     } catch (std::out_of_range& e) {
34671       {
34672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34673       };
34674     } catch (std::exception& e) {
34675       {
34676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34677       };
34678     } catch (Dali::DaliException e) {
34679       {
34680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34681       };
34682     } catch (...) {
34683       {
34684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34685       };
34686     }
34687   }
34688
34689   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34690   return jresult;
34691 }
34692
34693
34694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34696   float arg2 ;
34697   float arg3 ;
34698
34699   arg1 = (Dali::Actor *)jarg1;
34700   arg2 = (float)jarg2;
34701   arg3 = (float)jarg3;
34702   {
34703     try {
34704       (arg1)->SetPosition(arg2,arg3);
34705     } catch (std::out_of_range& e) {
34706       {
34707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34708       };
34709     } catch (std::exception& e) {
34710       {
34711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34712       };
34713     } catch (Dali::DaliException e) {
34714       {
34715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34716       };
34717     } catch (...) {
34718       {
34719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34720       };
34721     }
34722   }
34723
34724 }
34725
34726
34727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34728   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34729   float arg2 ;
34730   float arg3 ;
34731   float arg4 ;
34732
34733   arg1 = (Dali::Actor *)jarg1;
34734   arg2 = (float)jarg2;
34735   arg3 = (float)jarg3;
34736   arg4 = (float)jarg4;
34737   {
34738     try {
34739       (arg1)->SetPosition(arg2,arg3,arg4);
34740     } catch (std::out_of_range& e) {
34741       {
34742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34743       };
34744     } catch (std::exception& e) {
34745       {
34746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34747       };
34748     } catch (Dali::DaliException e) {
34749       {
34750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34751       };
34752     } catch (...) {
34753       {
34754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34755       };
34756     }
34757   }
34758
34759 }
34760
34761
34762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34763   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34764   Dali::Vector3 *arg2 = 0 ;
34765
34766   arg1 = (Dali::Actor *)jarg1;
34767   arg2 = (Dali::Vector3 *)jarg2;
34768   if (!arg2) {
34769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34770     return ;
34771   }
34772   {
34773     try {
34774       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34775     } catch (std::out_of_range& e) {
34776       {
34777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34778       };
34779     } catch (std::exception& e) {
34780       {
34781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34782       };
34783     } catch (Dali::DaliException e) {
34784       {
34785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34786       };
34787     } catch (...) {
34788       {
34789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34790       };
34791     }
34792   }
34793
34794 }
34795
34796
34797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34798   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34799   float arg2 ;
34800
34801   arg1 = (Dali::Actor *)jarg1;
34802   arg2 = (float)jarg2;
34803   {
34804     try {
34805       (arg1)->SetX(arg2);
34806     } catch (std::out_of_range& e) {
34807       {
34808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34809       };
34810     } catch (std::exception& e) {
34811       {
34812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34813       };
34814     } catch (Dali::DaliException e) {
34815       {
34816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34817       };
34818     } catch (...) {
34819       {
34820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34821       };
34822     }
34823   }
34824
34825 }
34826
34827
34828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34829   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34830   float arg2 ;
34831
34832   arg1 = (Dali::Actor *)jarg1;
34833   arg2 = (float)jarg2;
34834   {
34835     try {
34836       (arg1)->SetY(arg2);
34837     } catch (std::out_of_range& e) {
34838       {
34839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34840       };
34841     } catch (std::exception& e) {
34842       {
34843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34844       };
34845     } catch (Dali::DaliException e) {
34846       {
34847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34848       };
34849     } catch (...) {
34850       {
34851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34852       };
34853     }
34854   }
34855
34856 }
34857
34858
34859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34860   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34861   float arg2 ;
34862
34863   arg1 = (Dali::Actor *)jarg1;
34864   arg2 = (float)jarg2;
34865   {
34866     try {
34867       (arg1)->SetZ(arg2);
34868     } catch (std::out_of_range& e) {
34869       {
34870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34871       };
34872     } catch (std::exception& e) {
34873       {
34874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34875       };
34876     } catch (Dali::DaliException e) {
34877       {
34878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34879       };
34880     } catch (...) {
34881       {
34882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34883       };
34884     }
34885   }
34886
34887 }
34888
34889
34890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34891   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34892   Dali::Vector3 *arg2 = 0 ;
34893
34894   arg1 = (Dali::Actor *)jarg1;
34895   arg2 = (Dali::Vector3 *)jarg2;
34896   if (!arg2) {
34897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34898     return ;
34899   }
34900   {
34901     try {
34902       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34903     } catch (std::out_of_range& e) {
34904       {
34905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34906       };
34907     } catch (std::exception& e) {
34908       {
34909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34910       };
34911     } catch (Dali::DaliException e) {
34912       {
34913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34914       };
34915     } catch (...) {
34916       {
34917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34918       };
34919     }
34920   }
34921
34922 }
34923
34924
34925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34926   void * jresult ;
34927   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34928   Dali::Vector3 result;
34929
34930   arg1 = (Dali::Actor *)jarg1;
34931   {
34932     try {
34933       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34934     } catch (std::out_of_range& e) {
34935       {
34936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34937       };
34938     } catch (std::exception& e) {
34939       {
34940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34941       };
34942     } catch (Dali::DaliException e) {
34943       {
34944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34945       };
34946     } catch (...) {
34947       {
34948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34949       };
34950     }
34951   }
34952
34953   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34954   return jresult;
34955 }
34956
34957
34958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34959   void * jresult ;
34960   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34961   Dali::Vector3 result;
34962
34963   arg1 = (Dali::Actor *)jarg1;
34964   {
34965     try {
34966       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34967     } catch (std::out_of_range& e) {
34968       {
34969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34970       };
34971     } catch (std::exception& e) {
34972       {
34973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34974       };
34975     } catch (Dali::DaliException e) {
34976       {
34977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34978       };
34979     } catch (...) {
34980       {
34981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34982       };
34983     }
34984   }
34985
34986   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34987   return jresult;
34988 }
34989
34990
34991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34993   bool arg2 ;
34994
34995   arg1 = (Dali::Actor *)jarg1;
34996   arg2 = jarg2 ? true : false;
34997   {
34998     try {
34999       (arg1)->SetInheritPosition(arg2);
35000     } catch (std::out_of_range& e) {
35001       {
35002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35003       };
35004     } catch (std::exception& e) {
35005       {
35006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35007       };
35008     } catch (Dali::DaliException e) {
35009       {
35010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35011       };
35012     } catch (...) {
35013       {
35014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35015       };
35016     }
35017   }
35018
35019 }
35020
35021
35022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
35023   unsigned int jresult ;
35024   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35025   bool result;
35026
35027   arg1 = (Dali::Actor *)jarg1;
35028   {
35029     try {
35030       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
35031     } catch (std::out_of_range& e) {
35032       {
35033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35034       };
35035     } catch (std::exception& e) {
35036       {
35037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35038       };
35039     } catch (Dali::DaliException e) {
35040       {
35041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35042       };
35043     } catch (...) {
35044       {
35045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35046       };
35047     }
35048   }
35049
35050   jresult = result;
35051   return jresult;
35052 }
35053
35054
35055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35056   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35057   Dali::Degree *arg2 = 0 ;
35058   Dali::Vector3 *arg3 = 0 ;
35059
35060   arg1 = (Dali::Actor *)jarg1;
35061   arg2 = (Dali::Degree *)jarg2;
35062   if (!arg2) {
35063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35064     return ;
35065   }
35066   arg3 = (Dali::Vector3 *)jarg3;
35067   if (!arg3) {
35068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35069     return ;
35070   }
35071   {
35072     try {
35073       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35074     } catch (std::out_of_range& e) {
35075       {
35076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35077       };
35078     } catch (std::exception& e) {
35079       {
35080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35081       };
35082     } catch (Dali::DaliException e) {
35083       {
35084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35085       };
35086     } catch (...) {
35087       {
35088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35089       };
35090     }
35091   }
35092
35093 }
35094
35095
35096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35097   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35098   Dali::Radian *arg2 = 0 ;
35099   Dali::Vector3 *arg3 = 0 ;
35100
35101   arg1 = (Dali::Actor *)jarg1;
35102   arg2 = (Dali::Radian *)jarg2;
35103   if (!arg2) {
35104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35105     return ;
35106   }
35107   arg3 = (Dali::Vector3 *)jarg3;
35108   if (!arg3) {
35109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35110     return ;
35111   }
35112   {
35113     try {
35114       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35115     } catch (std::out_of_range& e) {
35116       {
35117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35118       };
35119     } catch (std::exception& e) {
35120       {
35121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35122       };
35123     } catch (Dali::DaliException e) {
35124       {
35125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35126       };
35127     } catch (...) {
35128       {
35129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35130       };
35131     }
35132   }
35133
35134 }
35135
35136
35137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35138   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35139   Dali::Quaternion *arg2 = 0 ;
35140
35141   arg1 = (Dali::Actor *)jarg1;
35142   arg2 = (Dali::Quaternion *)jarg2;
35143   if (!arg2) {
35144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35145     return ;
35146   }
35147   {
35148     try {
35149       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35150     } catch (std::out_of_range& e) {
35151       {
35152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35153       };
35154     } catch (std::exception& e) {
35155       {
35156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35157       };
35158     } catch (Dali::DaliException e) {
35159       {
35160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35161       };
35162     } catch (...) {
35163       {
35164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35165       };
35166     }
35167   }
35168
35169 }
35170
35171
35172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35173   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35174   Dali::Degree *arg2 = 0 ;
35175   Dali::Vector3 *arg3 = 0 ;
35176
35177   arg1 = (Dali::Actor *)jarg1;
35178   arg2 = (Dali::Degree *)jarg2;
35179   if (!arg2) {
35180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35181     return ;
35182   }
35183   arg3 = (Dali::Vector3 *)jarg3;
35184   if (!arg3) {
35185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35186     return ;
35187   }
35188   {
35189     try {
35190       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35191     } catch (std::out_of_range& e) {
35192       {
35193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35194       };
35195     } catch (std::exception& e) {
35196       {
35197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35198       };
35199     } catch (Dali::DaliException e) {
35200       {
35201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35202       };
35203     } catch (...) {
35204       {
35205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35206       };
35207     }
35208   }
35209
35210 }
35211
35212
35213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35214   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35215   Dali::Radian *arg2 = 0 ;
35216   Dali::Vector3 *arg3 = 0 ;
35217
35218   arg1 = (Dali::Actor *)jarg1;
35219   arg2 = (Dali::Radian *)jarg2;
35220   if (!arg2) {
35221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35222     return ;
35223   }
35224   arg3 = (Dali::Vector3 *)jarg3;
35225   if (!arg3) {
35226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35227     return ;
35228   }
35229   {
35230     try {
35231       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35232     } catch (std::out_of_range& e) {
35233       {
35234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35235       };
35236     } catch (std::exception& e) {
35237       {
35238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35239       };
35240     } catch (Dali::DaliException e) {
35241       {
35242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35243       };
35244     } catch (...) {
35245       {
35246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35247       };
35248     }
35249   }
35250
35251 }
35252
35253
35254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35256   Dali::Quaternion *arg2 = 0 ;
35257
35258   arg1 = (Dali::Actor *)jarg1;
35259   arg2 = (Dali::Quaternion *)jarg2;
35260   if (!arg2) {
35261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35262     return ;
35263   }
35264   {
35265     try {
35266       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35267     } catch (std::out_of_range& e) {
35268       {
35269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35270       };
35271     } catch (std::exception& e) {
35272       {
35273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35274       };
35275     } catch (Dali::DaliException e) {
35276       {
35277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35278       };
35279     } catch (...) {
35280       {
35281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35282       };
35283     }
35284   }
35285
35286 }
35287
35288
35289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35290   void * jresult ;
35291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35292   Dali::Quaternion result;
35293
35294   arg1 = (Dali::Actor *)jarg1;
35295   {
35296     try {
35297       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35298     } catch (std::out_of_range& e) {
35299       {
35300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35301       };
35302     } catch (std::exception& e) {
35303       {
35304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35305       };
35306     } catch (Dali::DaliException e) {
35307       {
35308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35309       };
35310     } catch (...) {
35311       {
35312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35313       };
35314     }
35315   }
35316
35317   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35318   return jresult;
35319 }
35320
35321
35322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35323   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35324   bool arg2 ;
35325
35326   arg1 = (Dali::Actor *)jarg1;
35327   arg2 = jarg2 ? true : false;
35328   {
35329     try {
35330       (arg1)->SetInheritOrientation(arg2);
35331     } catch (std::out_of_range& e) {
35332       {
35333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35334       };
35335     } catch (std::exception& e) {
35336       {
35337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35338       };
35339     } catch (Dali::DaliException e) {
35340       {
35341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35342       };
35343     } catch (...) {
35344       {
35345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35346       };
35347     }
35348   }
35349
35350 }
35351
35352
35353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35354   unsigned int jresult ;
35355   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35356   bool result;
35357
35358   arg1 = (Dali::Actor *)jarg1;
35359   {
35360     try {
35361       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35362     } catch (std::out_of_range& e) {
35363       {
35364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35365       };
35366     } catch (std::exception& e) {
35367       {
35368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35369       };
35370     } catch (Dali::DaliException e) {
35371       {
35372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35373       };
35374     } catch (...) {
35375       {
35376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35377       };
35378     }
35379   }
35380
35381   jresult = result;
35382   return jresult;
35383 }
35384
35385
35386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35387   void * jresult ;
35388   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35389   Dali::Quaternion result;
35390
35391   arg1 = (Dali::Actor *)jarg1;
35392   {
35393     try {
35394       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35395     } catch (std::out_of_range& e) {
35396       {
35397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35398       };
35399     } catch (std::exception& e) {
35400       {
35401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35402       };
35403     } catch (Dali::DaliException e) {
35404       {
35405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35406       };
35407     } catch (...) {
35408       {
35409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35410       };
35411     }
35412   }
35413
35414   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35415   return jresult;
35416 }
35417
35418
35419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35420   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35421   float arg2 ;
35422
35423   arg1 = (Dali::Actor *)jarg1;
35424   arg2 = (float)jarg2;
35425   {
35426     try {
35427       (arg1)->SetScale(arg2);
35428     } catch (std::out_of_range& e) {
35429       {
35430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35431       };
35432     } catch (std::exception& e) {
35433       {
35434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35435       };
35436     } catch (Dali::DaliException e) {
35437       {
35438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35439       };
35440     } catch (...) {
35441       {
35442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35443       };
35444     }
35445   }
35446
35447 }
35448
35449
35450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35451   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35452   float arg2 ;
35453   float arg3 ;
35454   float arg4 ;
35455
35456   arg1 = (Dali::Actor *)jarg1;
35457   arg2 = (float)jarg2;
35458   arg3 = (float)jarg3;
35459   arg4 = (float)jarg4;
35460   {
35461     try {
35462       (arg1)->SetScale(arg2,arg3,arg4);
35463     } catch (std::out_of_range& e) {
35464       {
35465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35466       };
35467     } catch (std::exception& e) {
35468       {
35469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35470       };
35471     } catch (Dali::DaliException e) {
35472       {
35473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35474       };
35475     } catch (...) {
35476       {
35477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35478       };
35479     }
35480   }
35481
35482 }
35483
35484
35485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35486   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35487   Dali::Vector3 *arg2 = 0 ;
35488
35489   arg1 = (Dali::Actor *)jarg1;
35490   arg2 = (Dali::Vector3 *)jarg2;
35491   if (!arg2) {
35492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35493     return ;
35494   }
35495   {
35496     try {
35497       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35498     } catch (std::out_of_range& e) {
35499       {
35500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35501       };
35502     } catch (std::exception& e) {
35503       {
35504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35505       };
35506     } catch (Dali::DaliException e) {
35507       {
35508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35509       };
35510     } catch (...) {
35511       {
35512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35513       };
35514     }
35515   }
35516
35517 }
35518
35519
35520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35521   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35522   Dali::Vector3 *arg2 = 0 ;
35523
35524   arg1 = (Dali::Actor *)jarg1;
35525   arg2 = (Dali::Vector3 *)jarg2;
35526   if (!arg2) {
35527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35528     return ;
35529   }
35530   {
35531     try {
35532       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35533     } catch (std::out_of_range& e) {
35534       {
35535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35536       };
35537     } catch (std::exception& e) {
35538       {
35539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35540       };
35541     } catch (Dali::DaliException e) {
35542       {
35543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35544       };
35545     } catch (...) {
35546       {
35547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35548       };
35549     }
35550   }
35551
35552 }
35553
35554
35555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35556   void * jresult ;
35557   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35558   Dali::Vector3 result;
35559
35560   arg1 = (Dali::Actor *)jarg1;
35561   {
35562     try {
35563       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35564     } catch (std::out_of_range& e) {
35565       {
35566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35567       };
35568     } catch (std::exception& e) {
35569       {
35570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35571       };
35572     } catch (Dali::DaliException e) {
35573       {
35574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35575       };
35576     } catch (...) {
35577       {
35578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35579       };
35580     }
35581   }
35582
35583   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35584   return jresult;
35585 }
35586
35587
35588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35589   void * jresult ;
35590   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35591   Dali::Vector3 result;
35592
35593   arg1 = (Dali::Actor *)jarg1;
35594   {
35595     try {
35596       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35597     } catch (std::out_of_range& e) {
35598       {
35599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35600       };
35601     } catch (std::exception& e) {
35602       {
35603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35604       };
35605     } catch (Dali::DaliException e) {
35606       {
35607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35608       };
35609     } catch (...) {
35610       {
35611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35612       };
35613     }
35614   }
35615
35616   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35617   return jresult;
35618 }
35619
35620
35621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35622   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35623   bool arg2 ;
35624
35625   arg1 = (Dali::Actor *)jarg1;
35626   arg2 = jarg2 ? true : false;
35627   {
35628     try {
35629       (arg1)->SetInheritScale(arg2);
35630     } catch (std::out_of_range& e) {
35631       {
35632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35633       };
35634     } catch (std::exception& e) {
35635       {
35636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35637       };
35638     } catch (Dali::DaliException e) {
35639       {
35640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35641       };
35642     } catch (...) {
35643       {
35644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35645       };
35646     }
35647   }
35648
35649 }
35650
35651
35652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35653   unsigned int jresult ;
35654   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35655   bool result;
35656
35657   arg1 = (Dali::Actor *)jarg1;
35658   {
35659     try {
35660       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35661     } catch (std::out_of_range& e) {
35662       {
35663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35664       };
35665     } catch (std::exception& e) {
35666       {
35667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35668       };
35669     } catch (Dali::DaliException e) {
35670       {
35671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35672       };
35673     } catch (...) {
35674       {
35675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35676       };
35677     }
35678   }
35679
35680   jresult = result;
35681   return jresult;
35682 }
35683
35684
35685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35686   void * jresult ;
35687   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35688   Dali::Matrix result;
35689
35690   arg1 = (Dali::Actor *)jarg1;
35691   {
35692     try {
35693       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35694     } catch (std::out_of_range& e) {
35695       {
35696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35697       };
35698     } catch (std::exception& e) {
35699       {
35700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35701       };
35702     } catch (Dali::DaliException e) {
35703       {
35704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35705       };
35706     } catch (...) {
35707       {
35708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35709       };
35710     }
35711   }
35712
35713   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35714   return jresult;
35715 }
35716
35717
35718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35720   bool arg2 ;
35721
35722   arg1 = (Dali::Actor *)jarg1;
35723   arg2 = jarg2 ? true : false;
35724   {
35725     try {
35726       (arg1)->SetVisible(arg2);
35727     } catch (std::out_of_range& e) {
35728       {
35729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35730       };
35731     } catch (std::exception& e) {
35732       {
35733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35734       };
35735     } catch (Dali::DaliException e) {
35736       {
35737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35738       };
35739     } catch (...) {
35740       {
35741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35742       };
35743     }
35744   }
35745
35746 }
35747
35748
35749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35750   unsigned int jresult ;
35751   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35752   bool result;
35753
35754   arg1 = (Dali::Actor *)jarg1;
35755   {
35756     try {
35757       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35758     } catch (std::out_of_range& e) {
35759       {
35760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35761       };
35762     } catch (std::exception& e) {
35763       {
35764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35765       };
35766     } catch (Dali::DaliException e) {
35767       {
35768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35769       };
35770     } catch (...) {
35771       {
35772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35773       };
35774     }
35775   }
35776
35777   jresult = result;
35778   return jresult;
35779 }
35780
35781
35782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35783   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35784   float arg2 ;
35785
35786   arg1 = (Dali::Actor *)jarg1;
35787   arg2 = (float)jarg2;
35788   {
35789     try {
35790       (arg1)->SetOpacity(arg2);
35791     } catch (std::out_of_range& e) {
35792       {
35793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35794       };
35795     } catch (std::exception& e) {
35796       {
35797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35798       };
35799     } catch (Dali::DaliException e) {
35800       {
35801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35802       };
35803     } catch (...) {
35804       {
35805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35806       };
35807     }
35808   }
35809
35810 }
35811
35812
35813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35814   float jresult ;
35815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35816   float result;
35817
35818   arg1 = (Dali::Actor *)jarg1;
35819   {
35820     try {
35821       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35822     } catch (std::out_of_range& e) {
35823       {
35824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35825       };
35826     } catch (std::exception& e) {
35827       {
35828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35829       };
35830     } catch (Dali::DaliException e) {
35831       {
35832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35833       };
35834     } catch (...) {
35835       {
35836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35837       };
35838     }
35839   }
35840
35841   jresult = result;
35842   return jresult;
35843 }
35844
35845
35846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35847   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35848   Dali::Vector4 *arg2 = 0 ;
35849
35850   arg1 = (Dali::Actor *)jarg1;
35851   arg2 = (Dali::Vector4 *)jarg2;
35852   if (!arg2) {
35853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35854     return ;
35855   }
35856   {
35857     try {
35858       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35859     } catch (std::out_of_range& e) {
35860       {
35861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35862       };
35863     } catch (std::exception& e) {
35864       {
35865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35866       };
35867     } catch (Dali::DaliException e) {
35868       {
35869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35870       };
35871     } catch (...) {
35872       {
35873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35874       };
35875     }
35876   }
35877
35878 }
35879
35880
35881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35882   void * jresult ;
35883   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35884   Dali::Vector4 result;
35885
35886   arg1 = (Dali::Actor *)jarg1;
35887   {
35888     try {
35889       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35890     } catch (std::out_of_range& e) {
35891       {
35892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35893       };
35894     } catch (std::exception& e) {
35895       {
35896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35897       };
35898     } catch (Dali::DaliException e) {
35899       {
35900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35901       };
35902     } catch (...) {
35903       {
35904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35905       };
35906     }
35907   }
35908
35909   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35910   return jresult;
35911 }
35912
35913
35914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35915   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35916   Dali::ColorMode arg2 ;
35917
35918   arg1 = (Dali::Actor *)jarg1;
35919   arg2 = (Dali::ColorMode)jarg2;
35920   {
35921     try {
35922       (arg1)->SetColorMode(arg2);
35923     } catch (std::out_of_range& e) {
35924       {
35925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35926       };
35927     } catch (std::exception& e) {
35928       {
35929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35930       };
35931     } catch (Dali::DaliException e) {
35932       {
35933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35934       };
35935     } catch (...) {
35936       {
35937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35938       };
35939     }
35940   }
35941
35942 }
35943
35944
35945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35946   int jresult ;
35947   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35948   Dali::ColorMode result;
35949
35950   arg1 = (Dali::Actor *)jarg1;
35951   {
35952     try {
35953       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35954     } catch (std::out_of_range& e) {
35955       {
35956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35957       };
35958     } catch (std::exception& e) {
35959       {
35960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35961       };
35962     } catch (Dali::DaliException e) {
35963       {
35964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35965       };
35966     } catch (...) {
35967       {
35968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35969       };
35970     }
35971   }
35972
35973   jresult = (int)result;
35974   return jresult;
35975 }
35976
35977
35978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35979   void * jresult ;
35980   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35981   Dali::Vector4 result;
35982
35983   arg1 = (Dali::Actor *)jarg1;
35984   {
35985     try {
35986       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35987     } catch (std::out_of_range& e) {
35988       {
35989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35990       };
35991     } catch (std::exception& e) {
35992       {
35993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35994       };
35995     } catch (Dali::DaliException e) {
35996       {
35997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35998       };
35999     } catch (...) {
36000       {
36001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36002       };
36003     }
36004   }
36005
36006   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
36007   return jresult;
36008 }
36009
36010
36011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
36012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36013   Dali::DrawMode::Type arg2 ;
36014
36015   arg1 = (Dali::Actor *)jarg1;
36016   arg2 = (Dali::DrawMode::Type)jarg2;
36017   {
36018     try {
36019       (arg1)->SetDrawMode(arg2);
36020     } catch (std::out_of_range& e) {
36021       {
36022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36023       };
36024     } catch (std::exception& e) {
36025       {
36026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36027       };
36028     } catch (Dali::DaliException e) {
36029       {
36030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36031       };
36032     } catch (...) {
36033       {
36034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36035       };
36036     }
36037   }
36038
36039 }
36040
36041
36042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
36043   int jresult ;
36044   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36045   Dali::DrawMode::Type result;
36046
36047   arg1 = (Dali::Actor *)jarg1;
36048   {
36049     try {
36050       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
36051     } catch (std::out_of_range& e) {
36052       {
36053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36054       };
36055     } catch (std::exception& e) {
36056       {
36057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36058       };
36059     } catch (Dali::DaliException e) {
36060       {
36061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36062       };
36063     } catch (...) {
36064       {
36065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36066       };
36067     }
36068   }
36069
36070   jresult = (int)result;
36071   return jresult;
36072 }
36073
36074
36075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36076   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36077   bool arg2 ;
36078
36079   arg1 = (Dali::Actor *)jarg1;
36080   arg2 = jarg2 ? true : false;
36081   {
36082     try {
36083       (arg1)->SetSensitive(arg2);
36084     } catch (std::out_of_range& e) {
36085       {
36086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36087       };
36088     } catch (std::exception& e) {
36089       {
36090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36091       };
36092     } catch (Dali::DaliException e) {
36093       {
36094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36095       };
36096     } catch (...) {
36097       {
36098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36099       };
36100     }
36101   }
36102
36103 }
36104
36105
36106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36107   unsigned int jresult ;
36108   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36109   bool result;
36110
36111   arg1 = (Dali::Actor *)jarg1;
36112   {
36113     try {
36114       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36115     } catch (std::out_of_range& e) {
36116       {
36117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36118       };
36119     } catch (std::exception& e) {
36120       {
36121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36122       };
36123     } catch (Dali::DaliException e) {
36124       {
36125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36126       };
36127     } catch (...) {
36128       {
36129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36130       };
36131     }
36132   }
36133
36134   jresult = result;
36135   return jresult;
36136 }
36137
36138
36139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36140   unsigned int jresult ;
36141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36142   float *arg2 = 0 ;
36143   float *arg3 = 0 ;
36144   float arg4 ;
36145   float arg5 ;
36146   bool result;
36147
36148   arg1 = (Dali::Actor *)jarg1;
36149   arg2 = (float *)jarg2;
36150   arg3 = (float *)jarg3;
36151   arg4 = (float)jarg4;
36152   arg5 = (float)jarg5;
36153   {
36154     try {
36155       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36156     } catch (std::out_of_range& e) {
36157       {
36158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36159       };
36160     } catch (std::exception& e) {
36161       {
36162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36163       };
36164     } catch (Dali::DaliException e) {
36165       {
36166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36167       };
36168     } catch (...) {
36169       {
36170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36171       };
36172     }
36173   }
36174
36175   jresult = result;
36176   return jresult;
36177 }
36178
36179
36180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36181   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36182   bool arg2 ;
36183
36184   arg1 = (Dali::Actor *)jarg1;
36185   arg2 = jarg2 ? true : false;
36186   {
36187     try {
36188       (arg1)->SetLeaveRequired(arg2);
36189     } catch (std::out_of_range& e) {
36190       {
36191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36192       };
36193     } catch (std::exception& e) {
36194       {
36195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36196       };
36197     } catch (Dali::DaliException e) {
36198       {
36199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36200       };
36201     } catch (...) {
36202       {
36203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36204       };
36205     }
36206   }
36207
36208 }
36209
36210
36211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36212   unsigned int jresult ;
36213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36214   bool result;
36215
36216   arg1 = (Dali::Actor *)jarg1;
36217   {
36218     try {
36219       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36220     } catch (std::out_of_range& e) {
36221       {
36222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36223       };
36224     } catch (std::exception& e) {
36225       {
36226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36227       };
36228     } catch (Dali::DaliException e) {
36229       {
36230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36231       };
36232     } catch (...) {
36233       {
36234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36235       };
36236     }
36237   }
36238
36239   jresult = result;
36240   return jresult;
36241 }
36242
36243
36244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36245   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36246   bool arg2 ;
36247
36248   arg1 = (Dali::Actor *)jarg1;
36249   arg2 = jarg2 ? true : false;
36250   {
36251     try {
36252       (arg1)->SetKeyboardFocusable(arg2);
36253     } catch (std::out_of_range& e) {
36254       {
36255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36256       };
36257     } catch (std::exception& e) {
36258       {
36259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36260       };
36261     } catch (Dali::DaliException e) {
36262       {
36263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36264       };
36265     } catch (...) {
36266       {
36267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36268       };
36269     }
36270   }
36271
36272 }
36273
36274
36275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36276   unsigned int jresult ;
36277   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36278   bool result;
36279
36280   arg1 = (Dali::Actor *)jarg1;
36281   {
36282     try {
36283       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36284     } catch (std::out_of_range& e) {
36285       {
36286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36287       };
36288     } catch (std::exception& e) {
36289       {
36290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36291       };
36292     } catch (Dali::DaliException e) {
36293       {
36294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36295       };
36296     } catch (...) {
36297       {
36298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36299       };
36300     }
36301   }
36302
36303   jresult = result;
36304   return jresult;
36305 }
36306
36307
36308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36309   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36310   Dali::ResizePolicy::Type arg2 ;
36311   Dali::Dimension::Type arg3 ;
36312
36313   arg1 = (Dali::Actor *)jarg1;
36314   arg2 = (Dali::ResizePolicy::Type)jarg2;
36315   arg3 = (Dali::Dimension::Type)jarg3;
36316   {
36317     try {
36318       (arg1)->SetResizePolicy(arg2,arg3);
36319     } catch (std::out_of_range& e) {
36320       {
36321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36322       };
36323     } catch (std::exception& e) {
36324       {
36325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36326       };
36327     } catch (Dali::DaliException e) {
36328       {
36329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36330       };
36331     } catch (...) {
36332       {
36333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36334       };
36335     }
36336   }
36337
36338 }
36339
36340
36341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36342   int jresult ;
36343   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36344   Dali::Dimension::Type arg2 ;
36345   Dali::ResizePolicy::Type result;
36346
36347   arg1 = (Dali::Actor *)jarg1;
36348   arg2 = (Dali::Dimension::Type)jarg2;
36349   {
36350     try {
36351       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36352     } catch (std::out_of_range& e) {
36353       {
36354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36355       };
36356     } catch (std::exception& e) {
36357       {
36358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36359       };
36360     } catch (Dali::DaliException e) {
36361       {
36362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36363       };
36364     } catch (...) {
36365       {
36366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36367       };
36368     }
36369   }
36370
36371   jresult = (int)result;
36372   return jresult;
36373 }
36374
36375
36376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36377   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36378   Dali::SizeScalePolicy::Type arg2 ;
36379
36380   arg1 = (Dali::Actor *)jarg1;
36381   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36382   {
36383     try {
36384       (arg1)->SetSizeScalePolicy(arg2);
36385     } catch (std::out_of_range& e) {
36386       {
36387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36388       };
36389     } catch (std::exception& e) {
36390       {
36391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36392       };
36393     } catch (Dali::DaliException e) {
36394       {
36395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36396       };
36397     } catch (...) {
36398       {
36399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36400       };
36401     }
36402   }
36403
36404 }
36405
36406
36407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36408   int jresult ;
36409   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36410   Dali::SizeScalePolicy::Type result;
36411
36412   arg1 = (Dali::Actor *)jarg1;
36413   {
36414     try {
36415       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36416     } catch (std::out_of_range& e) {
36417       {
36418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36419       };
36420     } catch (std::exception& e) {
36421       {
36422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36423       };
36424     } catch (Dali::DaliException e) {
36425       {
36426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36427       };
36428     } catch (...) {
36429       {
36430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36431       };
36432     }
36433   }
36434
36435   jresult = (int)result;
36436   return jresult;
36437 }
36438
36439
36440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36442   Dali::Vector3 *arg2 = 0 ;
36443
36444   arg1 = (Dali::Actor *)jarg1;
36445   arg2 = (Dali::Vector3 *)jarg2;
36446   if (!arg2) {
36447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36448     return ;
36449   }
36450   {
36451     try {
36452       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36453     } catch (std::out_of_range& e) {
36454       {
36455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36456       };
36457     } catch (std::exception& e) {
36458       {
36459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36460       };
36461     } catch (Dali::DaliException e) {
36462       {
36463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36464       };
36465     } catch (...) {
36466       {
36467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36468       };
36469     }
36470   }
36471
36472 }
36473
36474
36475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36476   void * jresult ;
36477   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36478   Dali::Vector3 result;
36479
36480   arg1 = (Dali::Actor *)jarg1;
36481   {
36482     try {
36483       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36484     } catch (std::out_of_range& e) {
36485       {
36486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36487       };
36488     } catch (std::exception& e) {
36489       {
36490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36491       };
36492     } catch (Dali::DaliException e) {
36493       {
36494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36495       };
36496     } catch (...) {
36497       {
36498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36499       };
36500     }
36501   }
36502
36503   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36504   return jresult;
36505 }
36506
36507
36508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36509   float jresult ;
36510   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36511   float arg2 ;
36512   float result;
36513
36514   arg1 = (Dali::Actor *)jarg1;
36515   arg2 = (float)jarg2;
36516   {
36517     try {
36518       result = (float)(arg1)->GetHeightForWidth(arg2);
36519     } catch (std::out_of_range& e) {
36520       {
36521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36522       };
36523     } catch (std::exception& e) {
36524       {
36525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36526       };
36527     } catch (Dali::DaliException e) {
36528       {
36529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36530       };
36531     } catch (...) {
36532       {
36533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36534       };
36535     }
36536   }
36537
36538   jresult = result;
36539   return jresult;
36540 }
36541
36542
36543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36544   float jresult ;
36545   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36546   float arg2 ;
36547   float result;
36548
36549   arg1 = (Dali::Actor *)jarg1;
36550   arg2 = (float)jarg2;
36551   {
36552     try {
36553       result = (float)(arg1)->GetWidthForHeight(arg2);
36554     } catch (std::out_of_range& e) {
36555       {
36556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36557       };
36558     } catch (std::exception& e) {
36559       {
36560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36561       };
36562     } catch (Dali::DaliException e) {
36563       {
36564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36565       };
36566     } catch (...) {
36567       {
36568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36569       };
36570     }
36571   }
36572
36573   jresult = result;
36574   return jresult;
36575 }
36576
36577
36578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36579   float jresult ;
36580   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36581   Dali::Dimension::Type arg2 ;
36582   float result;
36583
36584   arg1 = (Dali::Actor *)jarg1;
36585   arg2 = (Dali::Dimension::Type)jarg2;
36586   {
36587     try {
36588       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36589     } catch (std::out_of_range& e) {
36590       {
36591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36592       };
36593     } catch (std::exception& e) {
36594       {
36595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36596       };
36597     } catch (Dali::DaliException e) {
36598       {
36599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36600       };
36601     } catch (...) {
36602       {
36603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36604       };
36605     }
36606   }
36607
36608   jresult = result;
36609   return jresult;
36610 }
36611
36612
36613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36615   Dali::Padding *arg2 = 0 ;
36616
36617   arg1 = (Dali::Actor *)jarg1;
36618   arg2 = (Dali::Padding *)jarg2;
36619   if (!arg2) {
36620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36621     return ;
36622   }
36623   {
36624     try {
36625       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36626     } catch (std::out_of_range& e) {
36627       {
36628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36629       };
36630     } catch (std::exception& e) {
36631       {
36632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36633       };
36634     } catch (Dali::DaliException e) {
36635       {
36636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36637       };
36638     } catch (...) {
36639       {
36640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36641       };
36642     }
36643   }
36644
36645 }
36646
36647
36648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36649   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36650   Dali::Padding *arg2 = 0 ;
36651
36652   arg1 = (Dali::Actor *)jarg1;
36653   arg2 = (Dali::Padding *)jarg2;
36654   if (!arg2) {
36655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36656     return ;
36657   }
36658   {
36659     try {
36660       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36661     } catch (std::out_of_range& e) {
36662       {
36663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36664       };
36665     } catch (std::exception& e) {
36666       {
36667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36668       };
36669     } catch (Dali::DaliException e) {
36670       {
36671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36672       };
36673     } catch (...) {
36674       {
36675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36676       };
36677     }
36678   }
36679
36680 }
36681
36682
36683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36685   Dali::Vector2 *arg2 = 0 ;
36686
36687   arg1 = (Dali::Actor *)jarg1;
36688   arg2 = (Dali::Vector2 *)jarg2;
36689   if (!arg2) {
36690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36691     return ;
36692   }
36693   {
36694     try {
36695       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36696     } catch (std::out_of_range& e) {
36697       {
36698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36699       };
36700     } catch (std::exception& e) {
36701       {
36702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36703       };
36704     } catch (Dali::DaliException e) {
36705       {
36706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36707       };
36708     } catch (...) {
36709       {
36710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36711       };
36712     }
36713   }
36714
36715 }
36716
36717
36718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36719   void * jresult ;
36720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36721   Dali::Vector2 result;
36722
36723   arg1 = (Dali::Actor *)jarg1;
36724   {
36725     try {
36726       result = (arg1)->GetMinimumSize();
36727     } catch (std::out_of_range& e) {
36728       {
36729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36730       };
36731     } catch (std::exception& e) {
36732       {
36733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36734       };
36735     } catch (Dali::DaliException e) {
36736       {
36737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36738       };
36739     } catch (...) {
36740       {
36741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36742       };
36743     }
36744   }
36745
36746   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36747   return jresult;
36748 }
36749
36750
36751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36753   Dali::Vector2 *arg2 = 0 ;
36754
36755   arg1 = (Dali::Actor *)jarg1;
36756   arg2 = (Dali::Vector2 *)jarg2;
36757   if (!arg2) {
36758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36759     return ;
36760   }
36761   {
36762     try {
36763       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36764     } catch (std::out_of_range& e) {
36765       {
36766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36767       };
36768     } catch (std::exception& e) {
36769       {
36770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36771       };
36772     } catch (Dali::DaliException e) {
36773       {
36774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36775       };
36776     } catch (...) {
36777       {
36778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36779       };
36780     }
36781   }
36782
36783 }
36784
36785
36786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36787   void * jresult ;
36788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36789   Dali::Vector2 result;
36790
36791   arg1 = (Dali::Actor *)jarg1;
36792   {
36793     try {
36794       result = (arg1)->GetMaximumSize();
36795     } catch (std::out_of_range& e) {
36796       {
36797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36798       };
36799     } catch (std::exception& e) {
36800       {
36801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36802       };
36803     } catch (Dali::DaliException e) {
36804       {
36805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36806       };
36807     } catch (...) {
36808       {
36809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36810       };
36811     }
36812   }
36813
36814   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36815   return jresult;
36816 }
36817
36818
36819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36820   int jresult ;
36821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36822   int result;
36823
36824   arg1 = (Dali::Actor *)jarg1;
36825   {
36826     try {
36827       result = (int)(arg1)->GetHierarchyDepth();
36828       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36829     } catch (std::out_of_range& e) {
36830       {
36831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36832       };
36833     } catch (std::exception& e) {
36834       {
36835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36836       };
36837     } catch (Dali::DaliException e) {
36838       {
36839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36840       };
36841     } catch (...) {
36842       {
36843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36844       };
36845     }
36846   }
36847
36848   jresult = result;
36849   return jresult;
36850 }
36851
36852
36853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36854   unsigned int jresult ;
36855   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36856   Dali::Renderer *arg2 = 0 ;
36857   unsigned int result;
36858
36859   arg1 = (Dali::Actor *)jarg1;
36860   arg2 = (Dali::Renderer *)jarg2;
36861   if (!arg2) {
36862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36863     return 0;
36864   }
36865   {
36866     try {
36867       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36868     } catch (std::out_of_range& e) {
36869       {
36870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36871       };
36872     } catch (std::exception& e) {
36873       {
36874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36875       };
36876     } catch (Dali::DaliException e) {
36877       {
36878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36879       };
36880     } catch (...) {
36881       {
36882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36883       };
36884     }
36885   }
36886
36887   jresult = result;
36888   return jresult;
36889 }
36890
36891
36892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36893   unsigned int jresult ;
36894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36895   unsigned int result;
36896
36897   arg1 = (Dali::Actor *)jarg1;
36898   {
36899     try {
36900       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36901     } catch (std::out_of_range& e) {
36902       {
36903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36904       };
36905     } catch (std::exception& e) {
36906       {
36907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36908       };
36909     } catch (Dali::DaliException e) {
36910       {
36911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36912       };
36913     } catch (...) {
36914       {
36915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36916       };
36917     }
36918   }
36919
36920   jresult = result;
36921   return jresult;
36922 }
36923
36924
36925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36926   void * jresult ;
36927   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36928   unsigned int arg2 ;
36929   Dali::Renderer result;
36930
36931   arg1 = (Dali::Actor *)jarg1;
36932   arg2 = (unsigned int)jarg2;
36933   {
36934     try {
36935       result = (arg1)->GetRendererAt(arg2);
36936     } catch (std::out_of_range& e) {
36937       {
36938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36939       };
36940     } catch (std::exception& e) {
36941       {
36942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36943       };
36944     } catch (Dali::DaliException e) {
36945       {
36946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36947       };
36948     } catch (...) {
36949       {
36950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36951       };
36952     }
36953   }
36954
36955   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36956   return jresult;
36957 }
36958
36959
36960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36961   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36962   Dali::Renderer *arg2 = 0 ;
36963
36964   arg1 = (Dali::Actor *)jarg1;
36965   arg2 = (Dali::Renderer *)jarg2;
36966   if (!arg2) {
36967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36968     return ;
36969   }
36970   {
36971     try {
36972       (arg1)->RemoveRenderer(*arg2);
36973     } catch (std::out_of_range& e) {
36974       {
36975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36976       };
36977     } catch (std::exception& e) {
36978       {
36979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36980       };
36981     } catch (Dali::DaliException e) {
36982       {
36983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36984       };
36985     } catch (...) {
36986       {
36987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36988       };
36989     }
36990   }
36991
36992 }
36993
36994
36995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36996   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36997   unsigned int arg2 ;
36998
36999   arg1 = (Dali::Actor *)jarg1;
37000   arg2 = (unsigned int)jarg2;
37001   {
37002     try {
37003       (arg1)->RemoveRenderer(arg2);
37004     } catch (std::out_of_range& e) {
37005       {
37006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37007       };
37008     } catch (std::exception& e) {
37009       {
37010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37011       };
37012     } catch (Dali::DaliException e) {
37013       {
37014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37015       };
37016     } catch (...) {
37017       {
37018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37019       };
37020     }
37021   }
37022
37023 }
37024
37025
37026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
37027   void * jresult ;
37028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37029   Dali::Actor::TouchSignalType *result = 0 ;
37030
37031   arg1 = (Dali::Actor *)jarg1;
37032   {
37033     try {
37034       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
37035     } catch (std::out_of_range& e) {
37036       {
37037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37038       };
37039     } catch (std::exception& e) {
37040       {
37041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37042       };
37043     } catch (Dali::DaliException e) {
37044       {
37045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37046       };
37047     } catch (...) {
37048       {
37049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37050       };
37051     }
37052   }
37053
37054   jresult = (void *)result;
37055   return jresult;
37056 }
37057
37058
37059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
37060   void * jresult ;
37061   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37062   Dali::Actor::TouchDataSignalType *result = 0 ;
37063
37064   arg1 = (Dali::Actor *)jarg1;
37065   {
37066     try {
37067       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
37068     } catch (std::out_of_range& e) {
37069       {
37070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37071       };
37072     } catch (std::exception& e) {
37073       {
37074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37075       };
37076     } catch (Dali::DaliException e) {
37077       {
37078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37079       };
37080     } catch (...) {
37081       {
37082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37083       };
37084     }
37085   }
37086
37087   jresult = (void *)result;
37088   return jresult;
37089 }
37090
37091
37092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37093   void * jresult ;
37094   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37095   Dali::Actor::HoverSignalType *result = 0 ;
37096
37097   arg1 = (Dali::Actor *)jarg1;
37098   {
37099     try {
37100       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37101     } catch (std::out_of_range& e) {
37102       {
37103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37104       };
37105     } catch (std::exception& e) {
37106       {
37107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37108       };
37109     } catch (Dali::DaliException e) {
37110       {
37111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37112       };
37113     } catch (...) {
37114       {
37115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37116       };
37117     }
37118   }
37119
37120   jresult = (void *)result;
37121   return jresult;
37122 }
37123
37124
37125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37126   void * jresult ;
37127   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37128   Dali::Actor::WheelEventSignalType *result = 0 ;
37129
37130   arg1 = (Dali::Actor *)jarg1;
37131   {
37132     try {
37133       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37134     } catch (std::out_of_range& e) {
37135       {
37136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37137       };
37138     } catch (std::exception& e) {
37139       {
37140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37141       };
37142     } catch (Dali::DaliException e) {
37143       {
37144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37145       };
37146     } catch (...) {
37147       {
37148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37149       };
37150     }
37151   }
37152
37153   jresult = (void *)result;
37154   return jresult;
37155 }
37156
37157
37158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37159   void * jresult ;
37160   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37161   Dali::Actor::OnStageSignalType *result = 0 ;
37162
37163   arg1 = (Dali::Actor *)jarg1;
37164   {
37165     try {
37166       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37167     } catch (std::out_of_range& e) {
37168       {
37169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37170       };
37171     } catch (std::exception& e) {
37172       {
37173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37174       };
37175     } catch (Dali::DaliException e) {
37176       {
37177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37178       };
37179     } catch (...) {
37180       {
37181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37182       };
37183     }
37184   }
37185
37186   jresult = (void *)result;
37187   return jresult;
37188 }
37189
37190
37191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37192   void * jresult ;
37193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37194   Dali::Actor::OffStageSignalType *result = 0 ;
37195
37196   arg1 = (Dali::Actor *)jarg1;
37197   {
37198     try {
37199       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37200     } catch (std::out_of_range& e) {
37201       {
37202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37203       };
37204     } catch (std::exception& e) {
37205       {
37206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37207       };
37208     } catch (Dali::DaliException e) {
37209       {
37210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37211       };
37212     } catch (...) {
37213       {
37214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37215       };
37216     }
37217   }
37218
37219   jresult = (void *)result;
37220   return jresult;
37221 }
37222
37223
37224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37225   void * jresult ;
37226   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37227   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37228
37229   arg1 = (Dali::Actor *)jarg1;
37230   {
37231     try {
37232       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37233     } catch (std::out_of_range& e) {
37234       {
37235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37236       };
37237     } catch (std::exception& e) {
37238       {
37239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37240       };
37241     } catch (Dali::DaliException e) {
37242       {
37243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37244       };
37245     } catch (...) {
37246       {
37247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37248       };
37249     }
37250   }
37251
37252   jresult = (void *)result;
37253   return jresult;
37254 }
37255
37256
37257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37258   Dali::Actor *arg1 = 0 ;
37259
37260   arg1 = (Dali::Actor *)jarg1;
37261   if (!arg1) {
37262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37263     return ;
37264   }
37265   {
37266     try {
37267       Dali::UnparentAndReset(*arg1);
37268     } catch (std::out_of_range& e) {
37269       {
37270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37271       };
37272     } catch (std::exception& e) {
37273       {
37274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37275       };
37276     } catch (Dali::DaliException e) {
37277       {
37278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37279       };
37280     } catch (...) {
37281       {
37282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37283       };
37284     }
37285   }
37286
37287 }
37288
37289
37290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37291   int jresult ;
37292   int result;
37293
37294   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37295   jresult = (int)result;
37296   return jresult;
37297 }
37298
37299
37300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37301   int jresult ;
37302   int result;
37303
37304   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37305   jresult = (int)result;
37306   return jresult;
37307 }
37308
37309
37310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37311   int jresult ;
37312   int result;
37313
37314   result = (int)Dali::Layer::Property::BEHAVIOR;
37315   jresult = (int)result;
37316   return jresult;
37317 }
37318
37319
37320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37321   void * jresult ;
37322   Dali::Layer::Property *result = 0 ;
37323
37324   {
37325     try {
37326       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37327     } catch (std::out_of_range& e) {
37328       {
37329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37330       };
37331     } catch (std::exception& e) {
37332       {
37333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37334       };
37335     } catch (Dali::DaliException e) {
37336       {
37337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37338       };
37339     } catch (...) {
37340       {
37341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37342       };
37343     }
37344   }
37345
37346   jresult = (void *)result;
37347   return jresult;
37348 }
37349
37350
37351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37352   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37353
37354   arg1 = (Dali::Layer::Property *)jarg1;
37355   {
37356     try {
37357       delete arg1;
37358     } catch (std::out_of_range& e) {
37359       {
37360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37361       };
37362     } catch (std::exception& e) {
37363       {
37364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37365       };
37366     } catch (Dali::DaliException e) {
37367       {
37368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37369       };
37370     } catch (...) {
37371       {
37372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37373       };
37374     }
37375   }
37376
37377 }
37378
37379
37380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37381   void * jresult ;
37382   Dali::Layer *result = 0 ;
37383
37384   {
37385     try {
37386       result = (Dali::Layer *)new Dali::Layer();
37387     } catch (std::out_of_range& e) {
37388       {
37389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37390       };
37391     } catch (std::exception& e) {
37392       {
37393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37394       };
37395     } catch (Dali::DaliException e) {
37396       {
37397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37398       };
37399     } catch (...) {
37400       {
37401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37402       };
37403     }
37404   }
37405
37406   jresult = (void *)result;
37407   return jresult;
37408 }
37409
37410
37411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37412   void * jresult ;
37413   Dali::Layer result;
37414
37415   {
37416     try {
37417       result = Dali::Layer::New();
37418     } catch (std::out_of_range& e) {
37419       {
37420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37421       };
37422     } catch (std::exception& e) {
37423       {
37424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37425       };
37426     } catch (Dali::DaliException e) {
37427       {
37428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37429       };
37430     } catch (...) {
37431       {
37432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37433       };
37434     }
37435   }
37436
37437   jresult = new Dali::Layer((const Dali::Layer &)result);
37438   return jresult;
37439 }
37440
37441
37442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37443   void * jresult ;
37444   Dali::BaseHandle arg1 ;
37445   Dali::BaseHandle *argp1 ;
37446   Dali::Layer result;
37447
37448   argp1 = (Dali::BaseHandle *)jarg1;
37449   if (!argp1) {
37450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37451     return 0;
37452   }
37453   arg1 = *argp1;
37454   {
37455     try {
37456       result = Dali::Layer::DownCast(arg1);
37457     } catch (std::out_of_range& e) {
37458       {
37459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37460       };
37461     } catch (std::exception& e) {
37462       {
37463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37464       };
37465     } catch (Dali::DaliException e) {
37466       {
37467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37468       };
37469     } catch (...) {
37470       {
37471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37472       };
37473     }
37474   }
37475
37476   jresult = new Dali::Layer((const Dali::Layer &)result);
37477   return jresult;
37478 }
37479
37480
37481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37482   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37483
37484   arg1 = (Dali::Layer *)jarg1;
37485   {
37486     try {
37487       delete arg1;
37488     } catch (std::out_of_range& e) {
37489       {
37490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37491       };
37492     } catch (std::exception& e) {
37493       {
37494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37495       };
37496     } catch (Dali::DaliException e) {
37497       {
37498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37499       };
37500     } catch (...) {
37501       {
37502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37503       };
37504     }
37505   }
37506
37507 }
37508
37509
37510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37511   void * jresult ;
37512   Dali::Layer *arg1 = 0 ;
37513   Dali::Layer *result = 0 ;
37514
37515   arg1 = (Dali::Layer *)jarg1;
37516   if (!arg1) {
37517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37518     return 0;
37519   }
37520   {
37521     try {
37522       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37523     } catch (std::out_of_range& e) {
37524       {
37525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37526       };
37527     } catch (std::exception& e) {
37528       {
37529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37530       };
37531     } catch (Dali::DaliException e) {
37532       {
37533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37534       };
37535     } catch (...) {
37536       {
37537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37538       };
37539     }
37540   }
37541
37542   jresult = (void *)result;
37543   return jresult;
37544 }
37545
37546
37547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37548   void * jresult ;
37549   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37550   Dali::Layer *arg2 = 0 ;
37551   Dali::Layer *result = 0 ;
37552
37553   arg1 = (Dali::Layer *)jarg1;
37554   arg2 = (Dali::Layer *)jarg2;
37555   if (!arg2) {
37556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37557     return 0;
37558   }
37559   {
37560     try {
37561       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37562     } catch (std::out_of_range& e) {
37563       {
37564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37565       };
37566     } catch (std::exception& e) {
37567       {
37568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37569       };
37570     } catch (Dali::DaliException e) {
37571       {
37572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37573       };
37574     } catch (...) {
37575       {
37576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37577       };
37578     }
37579   }
37580
37581   jresult = (void *)result;
37582   return jresult;
37583 }
37584
37585
37586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37587   unsigned int jresult ;
37588   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37589   unsigned int result;
37590
37591   arg1 = (Dali::Layer *)jarg1;
37592   {
37593     try {
37594       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37595     } catch (std::out_of_range& e) {
37596       {
37597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37598       };
37599     } catch (std::exception& e) {
37600       {
37601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37602       };
37603     } catch (Dali::DaliException e) {
37604       {
37605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37606       };
37607     } catch (...) {
37608       {
37609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37610       };
37611     }
37612   }
37613
37614   jresult = result;
37615   return jresult;
37616 }
37617
37618
37619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37620   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37621
37622   arg1 = (Dali::Layer *)jarg1;
37623   {
37624     try {
37625       (arg1)->Raise();
37626     } catch (std::out_of_range& e) {
37627       {
37628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37629       };
37630     } catch (std::exception& e) {
37631       {
37632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37633       };
37634     } catch (Dali::DaliException e) {
37635       {
37636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37637       };
37638     } catch (...) {
37639       {
37640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37641       };
37642     }
37643   }
37644
37645 }
37646
37647
37648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37649   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37650
37651   arg1 = (Dali::Layer *)jarg1;
37652   {
37653     try {
37654       (arg1)->Lower();
37655     } catch (std::out_of_range& e) {
37656       {
37657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37658       };
37659     } catch (std::exception& e) {
37660       {
37661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37662       };
37663     } catch (Dali::DaliException e) {
37664       {
37665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37666       };
37667     } catch (...) {
37668       {
37669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37670       };
37671     }
37672   }
37673
37674 }
37675
37676
37677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37678   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37679   Dali::Layer arg2 ;
37680   Dali::Layer *argp2 ;
37681
37682   arg1 = (Dali::Layer *)jarg1;
37683   argp2 = (Dali::Layer *)jarg2;
37684   if (!argp2) {
37685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37686     return ;
37687   }
37688   arg2 = *argp2;
37689   {
37690     try {
37691       (arg1)->RaiseAbove(arg2);
37692     } catch (std::out_of_range& e) {
37693       {
37694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37695       };
37696     } catch (std::exception& e) {
37697       {
37698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37699       };
37700     } catch (Dali::DaliException e) {
37701       {
37702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37703       };
37704     } catch (...) {
37705       {
37706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37707       };
37708     }
37709   }
37710
37711 }
37712
37713
37714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37715   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37716   Dali::Layer arg2 ;
37717   Dali::Layer *argp2 ;
37718
37719   arg1 = (Dali::Layer *)jarg1;
37720   argp2 = (Dali::Layer *)jarg2;
37721   if (!argp2) {
37722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37723     return ;
37724   }
37725   arg2 = *argp2;
37726   {
37727     try {
37728       (arg1)->LowerBelow(arg2);
37729     } catch (std::out_of_range& e) {
37730       {
37731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37732       };
37733     } catch (std::exception& e) {
37734       {
37735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37736       };
37737     } catch (Dali::DaliException e) {
37738       {
37739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37740       };
37741     } catch (...) {
37742       {
37743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37744       };
37745     }
37746   }
37747
37748 }
37749
37750
37751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37752   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37753
37754   arg1 = (Dali::Layer *)jarg1;
37755   {
37756     try {
37757       (arg1)->RaiseToTop();
37758     } catch (std::out_of_range& e) {
37759       {
37760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37761       };
37762     } catch (std::exception& e) {
37763       {
37764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37765       };
37766     } catch (Dali::DaliException e) {
37767       {
37768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37769       };
37770     } catch (...) {
37771       {
37772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37773       };
37774     }
37775   }
37776
37777 }
37778
37779
37780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37781   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37782
37783   arg1 = (Dali::Layer *)jarg1;
37784   {
37785     try {
37786       (arg1)->LowerToBottom();
37787     } catch (std::out_of_range& e) {
37788       {
37789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37790       };
37791     } catch (std::exception& e) {
37792       {
37793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37794       };
37795     } catch (Dali::DaliException e) {
37796       {
37797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37798       };
37799     } catch (...) {
37800       {
37801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37802       };
37803     }
37804   }
37805
37806 }
37807
37808
37809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37810   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37811   Dali::Layer arg2 ;
37812   Dali::Layer *argp2 ;
37813
37814   arg1 = (Dali::Layer *)jarg1;
37815   argp2 = (Dali::Layer *)jarg2;
37816   if (!argp2) {
37817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37818     return ;
37819   }
37820   arg2 = *argp2;
37821   {
37822     try {
37823       (arg1)->MoveAbove(arg2);
37824     } catch (std::out_of_range& e) {
37825       {
37826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37827       };
37828     } catch (std::exception& e) {
37829       {
37830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37831       };
37832     } catch (Dali::DaliException e) {
37833       {
37834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37835       };
37836     } catch (...) {
37837       {
37838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37839       };
37840     }
37841   }
37842
37843 }
37844
37845
37846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37847   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37848   Dali::Layer arg2 ;
37849   Dali::Layer *argp2 ;
37850
37851   arg1 = (Dali::Layer *)jarg1;
37852   argp2 = (Dali::Layer *)jarg2;
37853   if (!argp2) {
37854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37855     return ;
37856   }
37857   arg2 = *argp2;
37858   {
37859     try {
37860       (arg1)->MoveBelow(arg2);
37861     } catch (std::out_of_range& e) {
37862       {
37863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37864       };
37865     } catch (std::exception& e) {
37866       {
37867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37868       };
37869     } catch (Dali::DaliException e) {
37870       {
37871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37872       };
37873     } catch (...) {
37874       {
37875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37876       };
37877     }
37878   }
37879
37880 }
37881
37882
37883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37884   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37885   Dali::Layer::Behavior arg2 ;
37886
37887   arg1 = (Dali::Layer *)jarg1;
37888   arg2 = (Dali::Layer::Behavior)jarg2;
37889   {
37890     try {
37891       (arg1)->SetBehavior(arg2);
37892     } catch (std::out_of_range& e) {
37893       {
37894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37895       };
37896     } catch (std::exception& e) {
37897       {
37898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37899       };
37900     } catch (Dali::DaliException e) {
37901       {
37902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37903       };
37904     } catch (...) {
37905       {
37906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37907       };
37908     }
37909   }
37910
37911 }
37912
37913
37914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37915   int jresult ;
37916   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37917   Dali::Layer::Behavior result;
37918
37919   arg1 = (Dali::Layer *)jarg1;
37920   {
37921     try {
37922       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37923     } catch (std::out_of_range& e) {
37924       {
37925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37926       };
37927     } catch (std::exception& e) {
37928       {
37929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37930       };
37931     } catch (Dali::DaliException e) {
37932       {
37933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37934       };
37935     } catch (...) {
37936       {
37937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37938       };
37939     }
37940   }
37941
37942   jresult = (int)result;
37943   return jresult;
37944 }
37945
37946
37947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37948   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37949   bool arg2 ;
37950
37951   arg1 = (Dali::Layer *)jarg1;
37952   arg2 = jarg2 ? true : false;
37953   {
37954     try {
37955       (arg1)->SetClipping(arg2);
37956     } catch (std::out_of_range& e) {
37957       {
37958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37959       };
37960     } catch (std::exception& e) {
37961       {
37962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37963       };
37964     } catch (Dali::DaliException e) {
37965       {
37966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37967       };
37968     } catch (...) {
37969       {
37970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37971       };
37972     }
37973   }
37974
37975 }
37976
37977
37978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37979   unsigned int jresult ;
37980   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37981   bool result;
37982
37983   arg1 = (Dali::Layer *)jarg1;
37984   {
37985     try {
37986       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37987     } catch (std::out_of_range& e) {
37988       {
37989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37990       };
37991     } catch (std::exception& e) {
37992       {
37993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37994       };
37995     } catch (Dali::DaliException e) {
37996       {
37997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37998       };
37999     } catch (...) {
38000       {
38001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38002       };
38003     }
38004   }
38005
38006   jresult = result;
38007   return jresult;
38008 }
38009
38010
38011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
38012   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38013   int arg2 ;
38014   int arg3 ;
38015   int arg4 ;
38016   int arg5 ;
38017
38018   arg1 = (Dali::Layer *)jarg1;
38019   arg2 = (int)jarg2;
38020   arg3 = (int)jarg3;
38021   arg4 = (int)jarg4;
38022   arg5 = (int)jarg5;
38023   {
38024     try {
38025       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
38026     } catch (std::out_of_range& e) {
38027       {
38028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38029       };
38030     } catch (std::exception& e) {
38031       {
38032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38033       };
38034     } catch (Dali::DaliException e) {
38035       {
38036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38037       };
38038     } catch (...) {
38039       {
38040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38041       };
38042     }
38043   }
38044
38045 }
38046
38047
38048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
38049   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38050   Dali::ClippingBox arg2 ;
38051   Dali::ClippingBox *argp2 ;
38052
38053   arg1 = (Dali::Layer *)jarg1;
38054   argp2 = (Dali::ClippingBox *)jarg2;
38055   if (!argp2) {
38056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
38057     return ;
38058   }
38059   arg2 = *argp2;
38060   {
38061     try {
38062       (arg1)->SetClippingBox(arg2);
38063     } catch (std::out_of_range& e) {
38064       {
38065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38066       };
38067     } catch (std::exception& e) {
38068       {
38069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38070       };
38071     } catch (Dali::DaliException e) {
38072       {
38073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38074       };
38075     } catch (...) {
38076       {
38077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38078       };
38079     }
38080   }
38081
38082 }
38083
38084
38085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38086   void * jresult ;
38087   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38088   Dali::ClippingBox result;
38089
38090   arg1 = (Dali::Layer *)jarg1;
38091   {
38092     try {
38093       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38094     } catch (std::out_of_range& e) {
38095       {
38096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38097       };
38098     } catch (std::exception& e) {
38099       {
38100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38101       };
38102     } catch (Dali::DaliException e) {
38103       {
38104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38105       };
38106     } catch (...) {
38107       {
38108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38109       };
38110     }
38111   }
38112
38113   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38114   return jresult;
38115 }
38116
38117
38118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38119   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38120   bool arg2 ;
38121
38122   arg1 = (Dali::Layer *)jarg1;
38123   arg2 = jarg2 ? true : false;
38124   {
38125     try {
38126       (arg1)->SetDepthTestDisabled(arg2);
38127     } catch (std::out_of_range& e) {
38128       {
38129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38130       };
38131     } catch (std::exception& e) {
38132       {
38133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38134       };
38135     } catch (Dali::DaliException e) {
38136       {
38137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38138       };
38139     } catch (...) {
38140       {
38141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38142       };
38143     }
38144   }
38145
38146 }
38147
38148
38149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38150   unsigned int jresult ;
38151   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38152   bool result;
38153
38154   arg1 = (Dali::Layer *)jarg1;
38155   {
38156     try {
38157       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38158     } catch (std::out_of_range& e) {
38159       {
38160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38161       };
38162     } catch (std::exception& e) {
38163       {
38164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38165       };
38166     } catch (Dali::DaliException e) {
38167       {
38168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38169       };
38170     } catch (...) {
38171       {
38172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38173       };
38174     }
38175   }
38176
38177   jresult = result;
38178   return jresult;
38179 }
38180
38181
38182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38183   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38184   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38185
38186   arg1 = (Dali::Layer *)jarg1;
38187   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38188   {
38189     try {
38190       (arg1)->SetSortFunction(arg2);
38191     } catch (std::out_of_range& e) {
38192       {
38193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38194       };
38195     } catch (std::exception& e) {
38196       {
38197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38198       };
38199     } catch (Dali::DaliException e) {
38200       {
38201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38202       };
38203     } catch (...) {
38204       {
38205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38206       };
38207     }
38208   }
38209
38210 }
38211
38212
38213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38214   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38215   bool arg2 ;
38216
38217   arg1 = (Dali::Layer *)jarg1;
38218   arg2 = jarg2 ? true : false;
38219   {
38220     try {
38221       (arg1)->SetTouchConsumed(arg2);
38222     } catch (std::out_of_range& e) {
38223       {
38224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38225       };
38226     } catch (std::exception& e) {
38227       {
38228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38229       };
38230     } catch (Dali::DaliException e) {
38231       {
38232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38233       };
38234     } catch (...) {
38235       {
38236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38237       };
38238     }
38239   }
38240
38241 }
38242
38243
38244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38245   unsigned int jresult ;
38246   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38247   bool result;
38248
38249   arg1 = (Dali::Layer *)jarg1;
38250   {
38251     try {
38252       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38253     } catch (std::out_of_range& e) {
38254       {
38255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38256       };
38257     } catch (std::exception& e) {
38258       {
38259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38260       };
38261     } catch (Dali::DaliException e) {
38262       {
38263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38264       };
38265     } catch (...) {
38266       {
38267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38268       };
38269     }
38270   }
38271
38272   jresult = result;
38273   return jresult;
38274 }
38275
38276
38277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38278   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38279   bool arg2 ;
38280
38281   arg1 = (Dali::Layer *)jarg1;
38282   arg2 = jarg2 ? true : false;
38283   {
38284     try {
38285       (arg1)->SetHoverConsumed(arg2);
38286     } catch (std::out_of_range& e) {
38287       {
38288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38289       };
38290     } catch (std::exception& e) {
38291       {
38292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38293       };
38294     } catch (Dali::DaliException e) {
38295       {
38296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38297       };
38298     } catch (...) {
38299       {
38300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38301       };
38302     }
38303   }
38304
38305 }
38306
38307
38308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38309   unsigned int jresult ;
38310   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38311   bool result;
38312
38313   arg1 = (Dali::Layer *)jarg1;
38314   {
38315     try {
38316       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38317     } catch (std::out_of_range& e) {
38318       {
38319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38320       };
38321     } catch (std::exception& e) {
38322       {
38323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38324       };
38325     } catch (Dali::DaliException e) {
38326       {
38327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38328       };
38329     } catch (...) {
38330       {
38331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38332       };
38333     }
38334   }
38335
38336   jresult = result;
38337   return jresult;
38338 }
38339
38340
38341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38342   void * jresult ;
38343   Dali::Vector4 *result = 0 ;
38344
38345   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38346   jresult = (void *)result;
38347   return jresult;
38348 }
38349
38350
38351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38352   void * jresult ;
38353   Dali::Vector4 *result = 0 ;
38354
38355   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38356   jresult = (void *)result;
38357   return jresult;
38358 }
38359
38360
38361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38362   void * jresult ;
38363   Dali::Stage *result = 0 ;
38364
38365   {
38366     try {
38367       result = (Dali::Stage *)new Dali::Stage();
38368     } catch (std::out_of_range& e) {
38369       {
38370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38371       };
38372     } catch (std::exception& e) {
38373       {
38374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38375       };
38376     } catch (Dali::DaliException e) {
38377       {
38378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38379       };
38380     } catch (...) {
38381       {
38382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38383       };
38384     }
38385   }
38386
38387   jresult = (void *)result;
38388   return jresult;
38389 }
38390
38391
38392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38393   void * jresult ;
38394   Dali::Stage result;
38395
38396   {
38397     try {
38398       result = Dali::Stage::GetCurrent();
38399     } catch (std::out_of_range& e) {
38400       {
38401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38402       };
38403     } catch (std::exception& e) {
38404       {
38405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38406       };
38407     } catch (Dali::DaliException e) {
38408       {
38409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38410       };
38411     } catch (...) {
38412       {
38413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38414       };
38415     }
38416   }
38417
38418   jresult = new Dali::Stage((const Dali::Stage &)result);
38419   return jresult;
38420 }
38421
38422
38423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38424   unsigned int jresult ;
38425   bool result;
38426
38427   {
38428     try {
38429       result = (bool)Dali::Stage::IsInstalled();
38430     } catch (std::out_of_range& e) {
38431       {
38432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38433       };
38434     } catch (std::exception& e) {
38435       {
38436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38437       };
38438     } catch (Dali::DaliException e) {
38439       {
38440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38441       };
38442     } catch (...) {
38443       {
38444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38445       };
38446     }
38447   }
38448
38449   jresult = result;
38450   return jresult;
38451 }
38452
38453
38454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38455   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38456
38457   arg1 = (Dali::Stage *)jarg1;
38458   {
38459     try {
38460       delete arg1;
38461     } catch (std::out_of_range& e) {
38462       {
38463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38464       };
38465     } catch (std::exception& e) {
38466       {
38467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38468       };
38469     } catch (Dali::DaliException e) {
38470       {
38471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38472       };
38473     } catch (...) {
38474       {
38475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38476       };
38477     }
38478   }
38479
38480 }
38481
38482
38483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38484   void * jresult ;
38485   Dali::Stage *arg1 = 0 ;
38486   Dali::Stage *result = 0 ;
38487
38488   arg1 = (Dali::Stage *)jarg1;
38489   if (!arg1) {
38490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38491     return 0;
38492   }
38493   {
38494     try {
38495       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38496     } catch (std::out_of_range& e) {
38497       {
38498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38499       };
38500     } catch (std::exception& e) {
38501       {
38502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38503       };
38504     } catch (Dali::DaliException e) {
38505       {
38506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38507       };
38508     } catch (...) {
38509       {
38510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38511       };
38512     }
38513   }
38514
38515   jresult = (void *)result;
38516   return jresult;
38517 }
38518
38519
38520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38521   void * jresult ;
38522   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38523   Dali::Stage *arg2 = 0 ;
38524   Dali::Stage *result = 0 ;
38525
38526   arg1 = (Dali::Stage *)jarg1;
38527   arg2 = (Dali::Stage *)jarg2;
38528   if (!arg2) {
38529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38530     return 0;
38531   }
38532   {
38533     try {
38534       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38535     } catch (std::out_of_range& e) {
38536       {
38537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38538       };
38539     } catch (std::exception& e) {
38540       {
38541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38542       };
38543     } catch (Dali::DaliException e) {
38544       {
38545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38546       };
38547     } catch (...) {
38548       {
38549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38550       };
38551     }
38552   }
38553
38554   jresult = (void *)result;
38555   return jresult;
38556 }
38557
38558
38559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38560   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38561   Dali::Actor *arg2 = 0 ;
38562
38563   arg1 = (Dali::Stage *)jarg1;
38564   arg2 = (Dali::Actor *)jarg2;
38565   if (!arg2) {
38566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38567     return ;
38568   }
38569   {
38570     try {
38571       (arg1)->Add(*arg2);
38572     } catch (std::out_of_range& e) {
38573       {
38574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38575       };
38576     } catch (std::exception& e) {
38577       {
38578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38579       };
38580     } catch (Dali::DaliException e) {
38581       {
38582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38583       };
38584     } catch (...) {
38585       {
38586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38587       };
38588     }
38589   }
38590
38591 }
38592
38593
38594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38595   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38596   Dali::Actor *arg2 = 0 ;
38597
38598   arg1 = (Dali::Stage *)jarg1;
38599   arg2 = (Dali::Actor *)jarg2;
38600   if (!arg2) {
38601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38602     return ;
38603   }
38604   {
38605     try {
38606       (arg1)->Remove(*arg2);
38607     } catch (std::out_of_range& e) {
38608       {
38609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38610       };
38611     } catch (std::exception& e) {
38612       {
38613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38614       };
38615     } catch (Dali::DaliException e) {
38616       {
38617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38618       };
38619     } catch (...) {
38620       {
38621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38622       };
38623     }
38624   }
38625
38626 }
38627
38628
38629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38630   void * jresult ;
38631   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38632   Dali::Vector2 result;
38633
38634   arg1 = (Dali::Stage *)jarg1;
38635   {
38636     try {
38637       result = ((Dali::Stage const *)arg1)->GetSize();
38638     } catch (std::out_of_range& e) {
38639       {
38640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38641       };
38642     } catch (std::exception& e) {
38643       {
38644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38645       };
38646     } catch (Dali::DaliException e) {
38647       {
38648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38649       };
38650     } catch (...) {
38651       {
38652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38653       };
38654     }
38655   }
38656
38657   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38658   return jresult;
38659 }
38660
38661
38662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38663   void * jresult ;
38664   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38665   Dali::RenderTaskList result;
38666
38667   arg1 = (Dali::Stage *)jarg1;
38668   {
38669     try {
38670       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38671     } catch (std::out_of_range& e) {
38672       {
38673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38674       };
38675     } catch (std::exception& e) {
38676       {
38677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38678       };
38679     } catch (Dali::DaliException e) {
38680       {
38681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38682       };
38683     } catch (...) {
38684       {
38685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38686       };
38687     }
38688   }
38689
38690   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38691   return jresult;
38692 }
38693
38694
38695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38696   unsigned int jresult ;
38697   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38698   unsigned int result;
38699
38700   arg1 = (Dali::Stage *)jarg1;
38701   {
38702     try {
38703       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38704     } catch (std::out_of_range& e) {
38705       {
38706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38707       };
38708     } catch (std::exception& e) {
38709       {
38710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38711       };
38712     } catch (Dali::DaliException e) {
38713       {
38714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38715       };
38716     } catch (...) {
38717       {
38718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38719       };
38720     }
38721   }
38722
38723   jresult = result;
38724   return jresult;
38725 }
38726
38727
38728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38729   void * jresult ;
38730   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38731   unsigned int arg2 ;
38732   Dali::Layer result;
38733
38734   arg1 = (Dali::Stage *)jarg1;
38735   arg2 = (unsigned int)jarg2;
38736   {
38737     try {
38738       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38739     } catch (std::out_of_range& e) {
38740       {
38741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38742       };
38743     } catch (std::exception& e) {
38744       {
38745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38746       };
38747     } catch (Dali::DaliException e) {
38748       {
38749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38750       };
38751     } catch (...) {
38752       {
38753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38754       };
38755     }
38756   }
38757
38758   jresult = new Dali::Layer((const Dali::Layer &)result);
38759   return jresult;
38760 }
38761
38762
38763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38764   void * jresult ;
38765   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38766   Dali::Layer result;
38767
38768   arg1 = (Dali::Stage *)jarg1;
38769   {
38770     try {
38771       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38772     } catch (std::out_of_range& e) {
38773       {
38774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38775       };
38776     } catch (std::exception& e) {
38777       {
38778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38779       };
38780     } catch (Dali::DaliException e) {
38781       {
38782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38783       };
38784     } catch (...) {
38785       {
38786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38787       };
38788     }
38789   }
38790
38791   jresult = new Dali::Layer((const Dali::Layer &)result);
38792   return jresult;
38793 }
38794
38795
38796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38797   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38798   Dali::Vector4 arg2 ;
38799   Dali::Vector4 *argp2 ;
38800
38801   arg1 = (Dali::Stage *)jarg1;
38802   argp2 = (Dali::Vector4 *)jarg2;
38803   if (!argp2) {
38804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38805     return ;
38806   }
38807   arg2 = *argp2;
38808   {
38809     try {
38810       (arg1)->SetBackgroundColor(arg2);
38811     } catch (std::out_of_range& e) {
38812       {
38813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38814       };
38815     } catch (std::exception& e) {
38816       {
38817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38818       };
38819     } catch (Dali::DaliException e) {
38820       {
38821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38822       };
38823     } catch (...) {
38824       {
38825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38826       };
38827     }
38828   }
38829
38830 }
38831
38832
38833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38834   void * jresult ;
38835   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38836   Dali::Vector4 result;
38837
38838   arg1 = (Dali::Stage *)jarg1;
38839   {
38840     try {
38841       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38842     } catch (std::out_of_range& e) {
38843       {
38844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38845       };
38846     } catch (std::exception& e) {
38847       {
38848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38849       };
38850     } catch (Dali::DaliException e) {
38851       {
38852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38853       };
38854     } catch (...) {
38855       {
38856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38857       };
38858     }
38859   }
38860
38861   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38862   return jresult;
38863 }
38864
38865
38866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38867   void * jresult ;
38868   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38869   Dali::Vector2 result;
38870
38871   arg1 = (Dali::Stage *)jarg1;
38872   {
38873     try {
38874       result = ((Dali::Stage const *)arg1)->GetDpi();
38875     } catch (std::out_of_range& e) {
38876       {
38877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38878       };
38879     } catch (std::exception& e) {
38880       {
38881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38882       };
38883     } catch (Dali::DaliException e) {
38884       {
38885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38886       };
38887     } catch (...) {
38888       {
38889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38890       };
38891     }
38892   }
38893
38894   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38895   return jresult;
38896 }
38897
38898
38899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38900   void * jresult ;
38901   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38902   Dali::ObjectRegistry result;
38903
38904   arg1 = (Dali::Stage *)jarg1;
38905   {
38906     try {
38907       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38908     } catch (std::out_of_range& e) {
38909       {
38910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38911       };
38912     } catch (std::exception& e) {
38913       {
38914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38915       };
38916     } catch (Dali::DaliException e) {
38917       {
38918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38919       };
38920     } catch (...) {
38921       {
38922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38923       };
38924     }
38925   }
38926
38927   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38928   return jresult;
38929 }
38930
38931
38932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38933   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38934   float arg2 ;
38935
38936   arg1 = (Dali::Stage *)jarg1;
38937   arg2 = (float)jarg2;
38938   {
38939     try {
38940       (arg1)->KeepRendering(arg2);
38941     } catch (std::out_of_range& e) {
38942       {
38943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38944       };
38945     } catch (std::exception& e) {
38946       {
38947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38948       };
38949     } catch (Dali::DaliException e) {
38950       {
38951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38952       };
38953     } catch (...) {
38954       {
38955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38956       };
38957     }
38958   }
38959
38960 }
38961
38962
38963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38964   void * jresult ;
38965   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38966   Dali::Stage::KeyEventSignalType *result = 0 ;
38967
38968   arg1 = (Dali::Stage *)jarg1;
38969   {
38970     try {
38971       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38972     } catch (std::out_of_range& e) {
38973       {
38974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38975       };
38976     } catch (std::exception& e) {
38977       {
38978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38979       };
38980     } catch (Dali::DaliException e) {
38981       {
38982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38983       };
38984     } catch (...) {
38985       {
38986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38987       };
38988     }
38989   }
38990
38991   jresult = (void *)result;
38992   return jresult;
38993 }
38994
38995
38996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38997   void * jresult ;
38998   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38999   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
39000
39001   arg1 = (Dali::Stage *)jarg1;
39002   {
39003     try {
39004       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
39005     } catch (std::out_of_range& e) {
39006       {
39007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39008       };
39009     } catch (std::exception& e) {
39010       {
39011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39012       };
39013     } catch (Dali::DaliException e) {
39014       {
39015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39016       };
39017     } catch (...) {
39018       {
39019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39020       };
39021     }
39022   }
39023
39024   jresult = (void *)result;
39025   return jresult;
39026 }
39027
39028
39029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
39030   void * jresult ;
39031   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39032   Dali::Stage::TouchSignalType *result = 0 ;
39033
39034   arg1 = (Dali::Stage *)jarg1;
39035   {
39036     try {
39037       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
39038     } catch (std::out_of_range& e) {
39039       {
39040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39041       };
39042     } catch (std::exception& e) {
39043       {
39044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39045       };
39046     } catch (Dali::DaliException e) {
39047       {
39048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39049       };
39050     } catch (...) {
39051       {
39052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39053       };
39054     }
39055   }
39056
39057   jresult = (void *)result;
39058   return jresult;
39059 }
39060
39061
39062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
39063   void * jresult ;
39064   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39065   Dali::Stage::WheelEventSignalType *result = 0 ;
39066
39067   arg1 = (Dali::Stage *)jarg1;
39068   {
39069     try {
39070       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
39071     } catch (std::out_of_range& e) {
39072       {
39073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39074       };
39075     } catch (std::exception& e) {
39076       {
39077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39078       };
39079     } catch (Dali::DaliException e) {
39080       {
39081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39082       };
39083     } catch (...) {
39084       {
39085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39086       };
39087     }
39088   }
39089
39090   jresult = (void *)result;
39091   return jresult;
39092 }
39093
39094
39095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39096   void * jresult ;
39097   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39098   Dali::Stage::ContextStatusSignal *result = 0 ;
39099
39100   arg1 = (Dali::Stage *)jarg1;
39101   {
39102     try {
39103       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39104     } catch (std::out_of_range& e) {
39105       {
39106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39107       };
39108     } catch (std::exception& e) {
39109       {
39110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39111       };
39112     } catch (Dali::DaliException e) {
39113       {
39114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39115       };
39116     } catch (...) {
39117       {
39118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39119       };
39120     }
39121   }
39122
39123   jresult = (void *)result;
39124   return jresult;
39125 }
39126
39127
39128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39129   void * jresult ;
39130   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39131   Dali::Stage::ContextStatusSignal *result = 0 ;
39132
39133   arg1 = (Dali::Stage *)jarg1;
39134   {
39135     try {
39136       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39137     } catch (std::out_of_range& e) {
39138       {
39139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39140       };
39141     } catch (std::exception& e) {
39142       {
39143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39144       };
39145     } catch (Dali::DaliException e) {
39146       {
39147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39148       };
39149     } catch (...) {
39150       {
39151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39152       };
39153     }
39154   }
39155
39156   jresult = (void *)result;
39157   return jresult;
39158 }
39159
39160
39161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39162   void * jresult ;
39163   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39164   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39165
39166   arg1 = (Dali::Stage *)jarg1;
39167   {
39168     try {
39169       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39170     } catch (std::out_of_range& e) {
39171       {
39172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39173       };
39174     } catch (std::exception& e) {
39175       {
39176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39177       };
39178     } catch (Dali::DaliException e) {
39179       {
39180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39181       };
39182     } catch (...) {
39183       {
39184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39185       };
39186     }
39187   }
39188
39189   jresult = (void *)result;
39190   return jresult;
39191 }
39192
39193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39194   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39195   Dali::DevelStage::Rendering arg2 ;
39196
39197   arg1 = (Dali::Stage *)jarg1;
39198   arg2 = (Dali::DevelStage::Rendering)jarg2;
39199   {
39200     try {
39201       DevelStage::SetRenderingBehavior(*arg1,arg2);
39202     } catch (std::out_of_range& e) {
39203       {
39204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39205       };
39206     } catch (std::exception& e) {
39207       {
39208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39209       };
39210     } catch (Dali::DaliException e) {
39211       {
39212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39213       };
39214     } catch (...) {
39215       {
39216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39217       };
39218     }
39219   }
39220
39221 }
39222
39223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39224
39225   int jresult ;
39226   int result ;
39227   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39228
39229   arg1 = (Dali::Stage *)jarg1;
39230   {
39231     try {
39232       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39233     } catch (std::out_of_range& e) {
39234       {
39235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39236       };
39237     } catch (std::exception& e) {
39238       {
39239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39240       };
39241     } catch (Dali::DaliException e) {
39242       {
39243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39244       };
39245     } catch (...) {
39246       {
39247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39248       };
39249     }
39250   }
39251
39252   jresult = result;
39253   return jresult;
39254 }
39255
39256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39257   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39258
39259   arg1 = (Dali::RelayoutContainer *)jarg1;
39260   {
39261     try {
39262       delete arg1;
39263     } catch (std::out_of_range& e) {
39264       {
39265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39266       };
39267     } catch (std::exception& e) {
39268       {
39269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39270       };
39271     } catch (Dali::DaliException e) {
39272       {
39273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39274       };
39275     } catch (...) {
39276       {
39277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39278       };
39279     }
39280   }
39281
39282 }
39283
39284
39285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39286   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39287   Dali::Actor *arg2 = 0 ;
39288   Dali::Vector2 *arg3 = 0 ;
39289
39290   arg1 = (Dali::RelayoutContainer *)jarg1;
39291   arg2 = (Dali::Actor *)jarg2;
39292   if (!arg2) {
39293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39294     return ;
39295   }
39296   arg3 = (Dali::Vector2 *)jarg3;
39297   if (!arg3) {
39298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39299     return ;
39300   }
39301   {
39302     try {
39303       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39304     } catch (std::out_of_range& e) {
39305       {
39306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39307       };
39308     } catch (std::exception& e) {
39309       {
39310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39311       };
39312     } catch (Dali::DaliException e) {
39313       {
39314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39315       };
39316     } catch (...) {
39317       {
39318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39319       };
39320     }
39321   }
39322
39323 }
39324
39325
39326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39327   void * jresult ;
39328   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39329   Dali::CustomActor result;
39330
39331   arg1 = (Dali::CustomActorImpl *)jarg1;
39332   {
39333     try {
39334       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39335     } catch (std::out_of_range& e) {
39336       {
39337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39338       };
39339     } catch (std::exception& e) {
39340       {
39341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39342       };
39343     } catch (Dali::DaliException e) {
39344       {
39345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39346       };
39347     } catch (...) {
39348       {
39349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39350       };
39351     }
39352   }
39353
39354   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39355   return jresult;
39356 }
39357
39358
39359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39360   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39361   int arg2 ;
39362
39363   arg1 = (Dali::CustomActorImpl *)jarg1;
39364   arg2 = (int)jarg2;
39365   {
39366     try {
39367       (arg1)->OnStageConnection(arg2);
39368     } catch (std::out_of_range& e) {
39369       {
39370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39371       };
39372     } catch (std::exception& e) {
39373       {
39374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39375       };
39376     } catch (Dali::DaliException e) {
39377       {
39378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39379       };
39380     } catch (...) {
39381       {
39382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39383       };
39384     }
39385   }
39386
39387 }
39388
39389
39390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39391   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39392
39393   arg1 = (Dali::CustomActorImpl *)jarg1;
39394   {
39395     try {
39396       (arg1)->OnStageDisconnection();
39397     } catch (std::out_of_range& e) {
39398       {
39399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39400       };
39401     } catch (std::exception& e) {
39402       {
39403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39404       };
39405     } catch (Dali::DaliException e) {
39406       {
39407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39408       };
39409     } catch (...) {
39410       {
39411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39412       };
39413     }
39414   }
39415
39416 }
39417
39418
39419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39420   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39421   Dali::Actor *arg2 = 0 ;
39422
39423   arg1 = (Dali::CustomActorImpl *)jarg1;
39424   arg2 = (Dali::Actor *)jarg2;
39425   if (!arg2) {
39426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39427     return ;
39428   }
39429   {
39430     try {
39431       (arg1)->OnChildAdd(*arg2);
39432     } catch (std::out_of_range& e) {
39433       {
39434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39435       };
39436     } catch (std::exception& e) {
39437       {
39438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39439       };
39440     } catch (Dali::DaliException e) {
39441       {
39442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39443       };
39444     } catch (...) {
39445       {
39446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39447       };
39448     }
39449   }
39450
39451 }
39452
39453
39454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39455   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39456   Dali::Actor *arg2 = 0 ;
39457
39458   arg1 = (Dali::CustomActorImpl *)jarg1;
39459   arg2 = (Dali::Actor *)jarg2;
39460   if (!arg2) {
39461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39462     return ;
39463   }
39464   {
39465     try {
39466       (arg1)->OnChildRemove(*arg2);
39467     } catch (std::out_of_range& e) {
39468       {
39469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39470       };
39471     } catch (std::exception& e) {
39472       {
39473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39474       };
39475     } catch (Dali::DaliException e) {
39476       {
39477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39478       };
39479     } catch (...) {
39480       {
39481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39482       };
39483     }
39484   }
39485
39486 }
39487
39488
39489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39490   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39491   Dali::Property::Index arg2 ;
39492   Dali::Property::Value arg3 ;
39493   Dali::Property::Value *argp3 ;
39494
39495   arg1 = (Dali::CustomActorImpl *)jarg1;
39496   arg2 = (Dali::Property::Index)jarg2;
39497   argp3 = (Dali::Property::Value *)jarg3;
39498   if (!argp3) {
39499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39500     return ;
39501   }
39502   arg3 = *argp3;
39503   {
39504     try {
39505       (arg1)->OnPropertySet(arg2,arg3);
39506     } catch (std::out_of_range& e) {
39507       {
39508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39509       };
39510     } catch (std::exception& e) {
39511       {
39512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39513       };
39514     } catch (Dali::DaliException e) {
39515       {
39516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39517       };
39518     } catch (...) {
39519       {
39520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39521       };
39522     }
39523   }
39524
39525 }
39526
39527
39528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39529   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39530   Dali::Vector3 *arg2 = 0 ;
39531
39532   arg1 = (Dali::CustomActorImpl *)jarg1;
39533   arg2 = (Dali::Vector3 *)jarg2;
39534   if (!arg2) {
39535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39536     return ;
39537   }
39538   {
39539     try {
39540       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39541     } catch (std::out_of_range& e) {
39542       {
39543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39544       };
39545     } catch (std::exception& e) {
39546       {
39547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39548       };
39549     } catch (Dali::DaliException e) {
39550       {
39551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39552       };
39553     } catch (...) {
39554       {
39555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39556       };
39557     }
39558   }
39559
39560 }
39561
39562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39563   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39564   Dali::Animation *arg2 = 0 ;
39565   Dali::Vector3 *arg3 = 0 ;
39566
39567   arg1 = (Dali::CustomActorImpl *)jarg1;
39568   arg2 = (Dali::Animation *)jarg2;
39569   if (!arg2) {
39570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39571     return ;
39572   }
39573   arg3 = (Dali::Vector3 *)jarg3;
39574   if (!arg3) {
39575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39576     return ;
39577   }
39578   {
39579     try {
39580       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39581     } catch (std::out_of_range& e) {
39582       {
39583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39584       };
39585     } catch (std::exception& e) {
39586       {
39587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39588       };
39589     } catch (Dali::DaliException e) {
39590       {
39591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39592       };
39593     } catch (...) {
39594       {
39595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39596       };
39597     }
39598   }
39599
39600 }
39601
39602
39603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39604   unsigned int jresult ;
39605   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39606   Dali::TouchEvent *arg2 = 0 ;
39607   bool result;
39608
39609   arg1 = (Dali::CustomActorImpl *)jarg1;
39610   arg2 = (Dali::TouchEvent *)jarg2;
39611   if (!arg2) {
39612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39613     return 0;
39614   }
39615   {
39616     try {
39617       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39618     } catch (std::out_of_range& e) {
39619       {
39620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39621       };
39622     } catch (std::exception& e) {
39623       {
39624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39625       };
39626     } catch (Dali::DaliException e) {
39627       {
39628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39629       };
39630     } catch (...) {
39631       {
39632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39633       };
39634     }
39635   }
39636
39637   jresult = result;
39638   return jresult;
39639 }
39640
39641
39642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39643   unsigned int jresult ;
39644   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39645   Dali::HoverEvent *arg2 = 0 ;
39646   bool result;
39647
39648   arg1 = (Dali::CustomActorImpl *)jarg1;
39649   arg2 = (Dali::HoverEvent *)jarg2;
39650   if (!arg2) {
39651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39652     return 0;
39653   }
39654   {
39655     try {
39656       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39657     } catch (std::out_of_range& e) {
39658       {
39659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39660       };
39661     } catch (std::exception& e) {
39662       {
39663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39664       };
39665     } catch (Dali::DaliException e) {
39666       {
39667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39668       };
39669     } catch (...) {
39670       {
39671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39672       };
39673     }
39674   }
39675
39676   jresult = result;
39677   return jresult;
39678 }
39679
39680
39681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39682   unsigned int jresult ;
39683   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39684   Dali::KeyEvent *arg2 = 0 ;
39685   bool result;
39686
39687   arg1 = (Dali::CustomActorImpl *)jarg1;
39688   arg2 = (Dali::KeyEvent *)jarg2;
39689   if (!arg2) {
39690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39691     return 0;
39692   }
39693   {
39694     try {
39695       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39696     } catch (std::out_of_range& e) {
39697       {
39698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39699       };
39700     } catch (std::exception& e) {
39701       {
39702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39703       };
39704     } catch (Dali::DaliException e) {
39705       {
39706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39707       };
39708     } catch (...) {
39709       {
39710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39711       };
39712     }
39713   }
39714
39715   jresult = result;
39716   return jresult;
39717 }
39718
39719
39720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39721   unsigned int jresult ;
39722   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39723   Dali::WheelEvent *arg2 = 0 ;
39724   bool result;
39725
39726   arg1 = (Dali::CustomActorImpl *)jarg1;
39727   arg2 = (Dali::WheelEvent *)jarg2;
39728   if (!arg2) {
39729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39730     return 0;
39731   }
39732   {
39733     try {
39734       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39735     } catch (std::out_of_range& e) {
39736       {
39737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39738       };
39739     } catch (std::exception& e) {
39740       {
39741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39742       };
39743     } catch (Dali::DaliException e) {
39744       {
39745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39746       };
39747     } catch (...) {
39748       {
39749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39750       };
39751     }
39752   }
39753
39754   jresult = result;
39755   return jresult;
39756 }
39757
39758
39759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39760   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39761   Dali::Vector2 *arg2 = 0 ;
39762   Dali::RelayoutContainer *arg3 = 0 ;
39763
39764   arg1 = (Dali::CustomActorImpl *)jarg1;
39765   arg2 = (Dali::Vector2 *)jarg2;
39766   if (!arg2) {
39767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39768     return ;
39769   }
39770   arg3 = (Dali::RelayoutContainer *)jarg3;
39771   if (!arg3) {
39772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39773     return ;
39774   }
39775   {
39776     try {
39777       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39778     } catch (std::out_of_range& e) {
39779       {
39780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39781       };
39782     } catch (std::exception& e) {
39783       {
39784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39785       };
39786     } catch (Dali::DaliException e) {
39787       {
39788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39789       };
39790     } catch (...) {
39791       {
39792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39793       };
39794     }
39795   }
39796
39797 }
39798
39799
39800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39801   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39802   Dali::ResizePolicy::Type arg2 ;
39803   Dali::Dimension::Type arg3 ;
39804
39805   arg1 = (Dali::CustomActorImpl *)jarg1;
39806   arg2 = (Dali::ResizePolicy::Type)jarg2;
39807   arg3 = (Dali::Dimension::Type)jarg3;
39808   {
39809     try {
39810       (arg1)->OnSetResizePolicy(arg2,arg3);
39811     } catch (std::out_of_range& e) {
39812       {
39813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39814       };
39815     } catch (std::exception& e) {
39816       {
39817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39818       };
39819     } catch (Dali::DaliException e) {
39820       {
39821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39822       };
39823     } catch (...) {
39824       {
39825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39826       };
39827     }
39828   }
39829
39830 }
39831
39832
39833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39834   void * jresult ;
39835   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39836   Dali::Vector3 result;
39837
39838   arg1 = (Dali::CustomActorImpl *)jarg1;
39839   {
39840     try {
39841       result = (arg1)->GetNaturalSize();
39842     } catch (std::out_of_range& e) {
39843       {
39844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39845       };
39846     } catch (std::exception& e) {
39847       {
39848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39849       };
39850     } catch (Dali::DaliException e) {
39851       {
39852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39853       };
39854     } catch (...) {
39855       {
39856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39857       };
39858     }
39859   }
39860
39861   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39862   return jresult;
39863 }
39864
39865
39866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39867   float jresult ;
39868   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39869   Dali::Actor *arg2 = 0 ;
39870   Dali::Dimension::Type arg3 ;
39871   float result;
39872
39873   arg1 = (Dali::CustomActorImpl *)jarg1;
39874   arg2 = (Dali::Actor *)jarg2;
39875   if (!arg2) {
39876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39877     return 0;
39878   }
39879   arg3 = (Dali::Dimension::Type)jarg3;
39880   {
39881     try {
39882       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39883     } catch (std::out_of_range& e) {
39884       {
39885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39886       };
39887     } catch (std::exception& e) {
39888       {
39889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39890       };
39891     } catch (Dali::DaliException e) {
39892       {
39893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39894       };
39895     } catch (...) {
39896       {
39897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39898       };
39899     }
39900   }
39901
39902   jresult = result;
39903   return jresult;
39904 }
39905
39906
39907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39908   float jresult ;
39909   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39910   float arg2 ;
39911   float result;
39912
39913   arg1 = (Dali::CustomActorImpl *)jarg1;
39914   arg2 = (float)jarg2;
39915   {
39916     try {
39917       result = (float)(arg1)->GetHeightForWidth(arg2);
39918     } catch (std::out_of_range& e) {
39919       {
39920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39921       };
39922     } catch (std::exception& e) {
39923       {
39924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39925       };
39926     } catch (Dali::DaliException e) {
39927       {
39928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39929       };
39930     } catch (...) {
39931       {
39932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39933       };
39934     }
39935   }
39936
39937   jresult = result;
39938   return jresult;
39939 }
39940
39941
39942 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39943   float jresult ;
39944   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39945   float arg2 ;
39946   float result;
39947
39948   arg1 = (Dali::CustomActorImpl *)jarg1;
39949   arg2 = (float)jarg2;
39950   {
39951     try {
39952       result = (float)(arg1)->GetWidthForHeight(arg2);
39953     } catch (std::out_of_range& e) {
39954       {
39955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39956       };
39957     } catch (std::exception& e) {
39958       {
39959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39960       };
39961     } catch (Dali::DaliException e) {
39962       {
39963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39964       };
39965     } catch (...) {
39966       {
39967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39968       };
39969     }
39970   }
39971
39972   jresult = result;
39973   return jresult;
39974 }
39975
39976
39977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39978   unsigned int jresult ;
39979   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39980   Dali::Dimension::Type arg2 ;
39981   bool result;
39982
39983   arg1 = (Dali::CustomActorImpl *)jarg1;
39984   arg2 = (Dali::Dimension::Type)jarg2;
39985   {
39986     try {
39987       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39988     } catch (std::out_of_range& e) {
39989       {
39990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39991       };
39992     } catch (std::exception& e) {
39993       {
39994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39995       };
39996     } catch (Dali::DaliException e) {
39997       {
39998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39999       };
40000     } catch (...) {
40001       {
40002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40003       };
40004     }
40005   }
40006
40007   jresult = result;
40008   return jresult;
40009 }
40010
40011
40012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
40013   unsigned int jresult ;
40014   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40015   bool result;
40016
40017   arg1 = (Dali::CustomActorImpl *)jarg1;
40018   {
40019     try {
40020       result = (bool)(arg1)->RelayoutDependentOnChildren();
40021     } catch (std::out_of_range& e) {
40022       {
40023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40024       };
40025     } catch (std::exception& e) {
40026       {
40027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40028       };
40029     } catch (Dali::DaliException e) {
40030       {
40031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40032       };
40033     } catch (...) {
40034       {
40035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40036       };
40037     }
40038   }
40039
40040   jresult = result;
40041   return jresult;
40042 }
40043
40044
40045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
40046   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40047   Dali::Dimension::Type arg2 ;
40048
40049   arg1 = (Dali::CustomActorImpl *)jarg1;
40050   arg2 = (Dali::Dimension::Type)jarg2;
40051   {
40052     try {
40053       (arg1)->OnCalculateRelayoutSize(arg2);
40054     } catch (std::out_of_range& e) {
40055       {
40056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40057       };
40058     } catch (std::exception& e) {
40059       {
40060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40061       };
40062     } catch (Dali::DaliException e) {
40063       {
40064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40065       };
40066     } catch (...) {
40067       {
40068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40069       };
40070     }
40071   }
40072
40073 }
40074
40075
40076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40077   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40078   float arg2 ;
40079   Dali::Dimension::Type arg3 ;
40080
40081   arg1 = (Dali::CustomActorImpl *)jarg1;
40082   arg2 = (float)jarg2;
40083   arg3 = (Dali::Dimension::Type)jarg3;
40084   {
40085     try {
40086       (arg1)->OnLayoutNegotiated(arg2,arg3);
40087     } catch (std::out_of_range& e) {
40088       {
40089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40090       };
40091     } catch (std::exception& e) {
40092       {
40093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40094       };
40095     } catch (Dali::DaliException e) {
40096       {
40097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40098       };
40099     } catch (...) {
40100       {
40101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40102       };
40103     }
40104   }
40105
40106 }
40107
40108
40109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40110   unsigned int jresult ;
40111   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40112   bool result;
40113
40114   arg1 = (Dali::CustomActorImpl *)jarg1;
40115   {
40116     try {
40117       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40118     } catch (std::out_of_range& e) {
40119       {
40120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40121       };
40122     } catch (std::exception& e) {
40123       {
40124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40125       };
40126     } catch (Dali::DaliException e) {
40127       {
40128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40129       };
40130     } catch (...) {
40131       {
40132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40133       };
40134     }
40135   }
40136
40137   jresult = result;
40138   return jresult;
40139 }
40140
40141
40142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40143   unsigned int jresult ;
40144   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40145   bool result;
40146
40147   arg1 = (Dali::CustomActorImpl *)jarg1;
40148   {
40149     try {
40150       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40151     } catch (std::out_of_range& e) {
40152       {
40153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40154       };
40155     } catch (std::exception& e) {
40156       {
40157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40158       };
40159     } catch (Dali::DaliException e) {
40160       {
40161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40162       };
40163     } catch (...) {
40164       {
40165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40166       };
40167     }
40168   }
40169
40170   jresult = result;
40171   return jresult;
40172 }
40173
40174
40175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40176   unsigned int jresult ;
40177   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40178   bool result;
40179
40180   arg1 = (Dali::CustomActorImpl *)jarg1;
40181   {
40182     try {
40183       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40184     } catch (std::out_of_range& e) {
40185       {
40186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40187       };
40188     } catch (std::exception& e) {
40189       {
40190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40191       };
40192     } catch (Dali::DaliException e) {
40193       {
40194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40195       };
40196     } catch (...) {
40197       {
40198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40199       };
40200     }
40201   }
40202
40203   jresult = result;
40204   return jresult;
40205 }
40206
40207
40208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40209   unsigned int jresult ;
40210   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40211   bool result;
40212
40213   arg1 = (Dali::CustomActorImpl *)jarg1;
40214   {
40215     try {
40216       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40217     } catch (std::out_of_range& e) {
40218       {
40219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40220       };
40221     } catch (std::exception& e) {
40222       {
40223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40224       };
40225     } catch (Dali::DaliException e) {
40226       {
40227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40228       };
40229     } catch (...) {
40230       {
40231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40232       };
40233     }
40234   }
40235
40236   jresult = result;
40237   return jresult;
40238 }
40239
40240
40241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40242   void * jresult ;
40243   Dali::CustomActor *result = 0 ;
40244
40245   {
40246     try {
40247       result = (Dali::CustomActor *)new Dali::CustomActor();
40248     } catch (std::out_of_range& e) {
40249       {
40250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40251       };
40252     } catch (std::exception& e) {
40253       {
40254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40255       };
40256     } catch (Dali::DaliException e) {
40257       {
40258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40259       };
40260     } catch (...) {
40261       {
40262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40263       };
40264     }
40265   }
40266
40267   jresult = (void *)result;
40268   return jresult;
40269 }
40270
40271
40272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40273   void * jresult ;
40274   Dali::BaseHandle arg1 ;
40275   Dali::BaseHandle *argp1 ;
40276   Dali::CustomActor result;
40277
40278   argp1 = (Dali::BaseHandle *)jarg1;
40279   if (!argp1) {
40280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40281     return 0;
40282   }
40283   arg1 = *argp1;
40284   {
40285     try {
40286       result = Dali::CustomActor::DownCast(arg1);
40287     } catch (std::out_of_range& e) {
40288       {
40289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40290       };
40291     } catch (std::exception& e) {
40292       {
40293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40294       };
40295     } catch (Dali::DaliException e) {
40296       {
40297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40298       };
40299     } catch (...) {
40300       {
40301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40302       };
40303     }
40304   }
40305
40306   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40307   return jresult;
40308 }
40309
40310
40311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40312   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40313
40314   arg1 = (Dali::CustomActor *)jarg1;
40315   {
40316     try {
40317       delete arg1;
40318     } catch (std::out_of_range& e) {
40319       {
40320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40321       };
40322     } catch (std::exception& e) {
40323       {
40324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40325       };
40326     } catch (Dali::DaliException e) {
40327       {
40328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40329       };
40330     } catch (...) {
40331       {
40332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40333       };
40334     }
40335   }
40336
40337 }
40338
40339
40340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40341   void * jresult ;
40342   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40343   Dali::CustomActorImpl *result = 0 ;
40344
40345   arg1 = (Dali::CustomActor *)jarg1;
40346   {
40347     try {
40348       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40349     } catch (std::out_of_range& e) {
40350       {
40351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40352       };
40353     } catch (std::exception& e) {
40354       {
40355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40356       };
40357     } catch (Dali::DaliException e) {
40358       {
40359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40360       };
40361     } catch (...) {
40362       {
40363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40364       };
40365     }
40366   }
40367
40368   jresult = (void *)result;
40369   return jresult;
40370 }
40371
40372
40373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40374   void * jresult ;
40375   Dali::CustomActorImpl *arg1 = 0 ;
40376   Dali::CustomActor *result = 0 ;
40377
40378   arg1 = (Dali::CustomActorImpl *)jarg1;
40379   if (!arg1) {
40380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40381     return 0;
40382   }
40383   {
40384     try {
40385       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40386     } catch (std::out_of_range& e) {
40387       {
40388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40389       };
40390     } catch (std::exception& e) {
40391       {
40392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40393       };
40394     } catch (Dali::DaliException e) {
40395       {
40396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40397       };
40398     } catch (...) {
40399       {
40400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40401       };
40402     }
40403   }
40404
40405   jresult = (void *)result;
40406   return jresult;
40407 }
40408
40409
40410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40411   void * jresult ;
40412   Dali::CustomActor *arg1 = 0 ;
40413   Dali::CustomActor *result = 0 ;
40414
40415   arg1 = (Dali::CustomActor *)jarg1;
40416   if (!arg1) {
40417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40418     return 0;
40419   }
40420   {
40421     try {
40422       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40423     } catch (std::out_of_range& e) {
40424       {
40425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40426       };
40427     } catch (std::exception& e) {
40428       {
40429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40430       };
40431     } catch (Dali::DaliException e) {
40432       {
40433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40434       };
40435     } catch (...) {
40436       {
40437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40438       };
40439     }
40440   }
40441
40442   jresult = (void *)result;
40443   return jresult;
40444 }
40445
40446
40447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40448   void * jresult ;
40449   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40450   Dali::CustomActor *arg2 = 0 ;
40451   Dali::CustomActor *result = 0 ;
40452
40453   arg1 = (Dali::CustomActor *)jarg1;
40454   arg2 = (Dali::CustomActor *)jarg2;
40455   if (!arg2) {
40456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40457     return 0;
40458   }
40459   {
40460     try {
40461       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40462     } catch (std::out_of_range& e) {
40463       {
40464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40465       };
40466     } catch (std::exception& e) {
40467       {
40468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40469       };
40470     } catch (Dali::DaliException e) {
40471       {
40472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40473       };
40474     } catch (...) {
40475       {
40476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40477       };
40478     }
40479   }
40480
40481   jresult = (void *)result;
40482   return jresult;
40483 }
40484
40485
40486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40487   int jresult ;
40488   int result;
40489
40490   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40491   jresult = (int)result;
40492   return jresult;
40493 }
40494
40495
40496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40497   int jresult ;
40498   int result;
40499
40500   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40501   jresult = (int)result;
40502   return jresult;
40503 }
40504
40505
40506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40507   int jresult ;
40508   int result;
40509
40510   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40511   jresult = (int)result;
40512   return jresult;
40513 }
40514
40515
40516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40517   int jresult ;
40518   int result;
40519
40520   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40521   jresult = (int)result;
40522   return jresult;
40523 }
40524
40525
40526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40527   int jresult ;
40528   int result;
40529
40530   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40531   jresult = (int)result;
40532   return jresult;
40533 }
40534
40535
40536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40537   int jresult ;
40538   int result;
40539
40540   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40541   jresult = (int)result;
40542   return jresult;
40543 }
40544
40545
40546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40547   int jresult ;
40548   int result;
40549
40550   result = (int)Dali::PanGestureDetector::Property::PANNING;
40551   jresult = (int)result;
40552   return jresult;
40553 }
40554
40555
40556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40557   void * jresult ;
40558   Dali::PanGestureDetector::Property *result = 0 ;
40559
40560   {
40561     try {
40562       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40563     } catch (std::out_of_range& e) {
40564       {
40565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40566       };
40567     } catch (std::exception& e) {
40568       {
40569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (Dali::DaliException e) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40574       };
40575     } catch (...) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40578       };
40579     }
40580   }
40581
40582   jresult = (void *)result;
40583   return jresult;
40584 }
40585
40586
40587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40588   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40589
40590   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40591   {
40592     try {
40593       delete arg1;
40594     } catch (std::out_of_range& e) {
40595       {
40596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40597       };
40598     } catch (std::exception& e) {
40599       {
40600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40601       };
40602     } catch (Dali::DaliException e) {
40603       {
40604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40605       };
40606     } catch (...) {
40607       {
40608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40609       };
40610     }
40611   }
40612
40613 }
40614
40615
40616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40617   void * jresult ;
40618   Dali::Radian *result = 0 ;
40619
40620   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40621   jresult = (void *)result;
40622   return jresult;
40623 }
40624
40625
40626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40627   void * jresult ;
40628   Dali::Radian *result = 0 ;
40629
40630   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40631   jresult = (void *)result;
40632   return jresult;
40633 }
40634
40635
40636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40637   void * jresult ;
40638   Dali::Radian *result = 0 ;
40639
40640   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40641   jresult = (void *)result;
40642   return jresult;
40643 }
40644
40645
40646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40647   void * jresult ;
40648   Dali::Radian *result = 0 ;
40649
40650   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40651   jresult = (void *)result;
40652   return jresult;
40653 }
40654
40655
40656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40657   void * jresult ;
40658   Dali::Radian *result = 0 ;
40659
40660   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40661   jresult = (void *)result;
40662   return jresult;
40663 }
40664
40665
40666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40667   void * jresult ;
40668   Dali::Radian *result = 0 ;
40669
40670   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40671   jresult = (void *)result;
40672   return jresult;
40673 }
40674
40675
40676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40677   void * jresult ;
40678   Dali::Radian *result = 0 ;
40679
40680   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40681   jresult = (void *)result;
40682   return jresult;
40683 }
40684
40685
40686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40687   void * jresult ;
40688   Dali::PanGestureDetector *result = 0 ;
40689
40690   {
40691     try {
40692       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40693     } catch (std::out_of_range& e) {
40694       {
40695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40696       };
40697     } catch (std::exception& e) {
40698       {
40699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40700       };
40701     } catch (Dali::DaliException e) {
40702       {
40703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40704       };
40705     } catch (...) {
40706       {
40707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40708       };
40709     }
40710   }
40711
40712   jresult = (void *)result;
40713   return jresult;
40714 }
40715
40716
40717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40718   void * jresult ;
40719   Dali::PanGestureDetector result;
40720
40721   {
40722     try {
40723       result = Dali::PanGestureDetector::New();
40724     } catch (std::out_of_range& e) {
40725       {
40726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40727       };
40728     } catch (std::exception& e) {
40729       {
40730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40731       };
40732     } catch (Dali::DaliException e) {
40733       {
40734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40735       };
40736     } catch (...) {
40737       {
40738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40739       };
40740     }
40741   }
40742
40743   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40744   return jresult;
40745 }
40746
40747
40748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40749   void * jresult ;
40750   Dali::BaseHandle arg1 ;
40751   Dali::BaseHandle *argp1 ;
40752   Dali::PanGestureDetector result;
40753
40754   argp1 = (Dali::BaseHandle *)jarg1;
40755   if (!argp1) {
40756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40757     return 0;
40758   }
40759   arg1 = *argp1;
40760   {
40761     try {
40762       result = Dali::PanGestureDetector::DownCast(arg1);
40763     } catch (std::out_of_range& e) {
40764       {
40765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40766       };
40767     } catch (std::exception& e) {
40768       {
40769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40770       };
40771     } catch (Dali::DaliException e) {
40772       {
40773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40774       };
40775     } catch (...) {
40776       {
40777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40778       };
40779     }
40780   }
40781
40782   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40783   return jresult;
40784 }
40785
40786
40787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40788   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40789
40790   arg1 = (Dali::PanGestureDetector *)jarg1;
40791   {
40792     try {
40793       delete arg1;
40794     } catch (std::out_of_range& e) {
40795       {
40796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40797       };
40798     } catch (std::exception& e) {
40799       {
40800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40801       };
40802     } catch (Dali::DaliException e) {
40803       {
40804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40805       };
40806     } catch (...) {
40807       {
40808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40809       };
40810     }
40811   }
40812
40813 }
40814
40815
40816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40817   void * jresult ;
40818   Dali::PanGestureDetector *arg1 = 0 ;
40819   Dali::PanGestureDetector *result = 0 ;
40820
40821   arg1 = (Dali::PanGestureDetector *)jarg1;
40822   if (!arg1) {
40823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40824     return 0;
40825   }
40826   {
40827     try {
40828       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40829     } catch (std::out_of_range& e) {
40830       {
40831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40832       };
40833     } catch (std::exception& e) {
40834       {
40835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40836       };
40837     } catch (Dali::DaliException e) {
40838       {
40839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40840       };
40841     } catch (...) {
40842       {
40843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40844       };
40845     }
40846   }
40847
40848   jresult = (void *)result;
40849   return jresult;
40850 }
40851
40852
40853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40854   void * jresult ;
40855   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40856   Dali::PanGestureDetector *arg2 = 0 ;
40857   Dali::PanGestureDetector *result = 0 ;
40858
40859   arg1 = (Dali::PanGestureDetector *)jarg1;
40860   arg2 = (Dali::PanGestureDetector *)jarg2;
40861   if (!arg2) {
40862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40863     return 0;
40864   }
40865   {
40866     try {
40867       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40868     } catch (std::out_of_range& e) {
40869       {
40870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40871       };
40872     } catch (std::exception& e) {
40873       {
40874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40875       };
40876     } catch (Dali::DaliException e) {
40877       {
40878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40879       };
40880     } catch (...) {
40881       {
40882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40883       };
40884     }
40885   }
40886
40887   jresult = (void *)result;
40888   return jresult;
40889 }
40890
40891
40892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40893   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40894   unsigned int arg2 ;
40895
40896   arg1 = (Dali::PanGestureDetector *)jarg1;
40897   arg2 = (unsigned int)jarg2;
40898   {
40899     try {
40900       (arg1)->SetMinimumTouchesRequired(arg2);
40901     } catch (std::out_of_range& e) {
40902       {
40903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40904       };
40905     } catch (std::exception& e) {
40906       {
40907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40908       };
40909     } catch (Dali::DaliException e) {
40910       {
40911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40912       };
40913     } catch (...) {
40914       {
40915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40916       };
40917     }
40918   }
40919
40920 }
40921
40922
40923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40924   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40925   unsigned int arg2 ;
40926
40927   arg1 = (Dali::PanGestureDetector *)jarg1;
40928   arg2 = (unsigned int)jarg2;
40929   {
40930     try {
40931       (arg1)->SetMaximumTouchesRequired(arg2);
40932     } catch (std::out_of_range& e) {
40933       {
40934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40935       };
40936     } catch (std::exception& e) {
40937       {
40938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40939       };
40940     } catch (Dali::DaliException e) {
40941       {
40942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40943       };
40944     } catch (...) {
40945       {
40946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40947       };
40948     }
40949   }
40950
40951 }
40952
40953
40954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40955   unsigned int jresult ;
40956   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40957   unsigned int result;
40958
40959   arg1 = (Dali::PanGestureDetector *)jarg1;
40960   {
40961     try {
40962       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40963     } catch (std::out_of_range& e) {
40964       {
40965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40966       };
40967     } catch (std::exception& e) {
40968       {
40969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40970       };
40971     } catch (Dali::DaliException e) {
40972       {
40973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40974       };
40975     } catch (...) {
40976       {
40977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40978       };
40979     }
40980   }
40981
40982   jresult = result;
40983   return jresult;
40984 }
40985
40986
40987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40988   unsigned int jresult ;
40989   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40990   unsigned int result;
40991
40992   arg1 = (Dali::PanGestureDetector *)jarg1;
40993   {
40994     try {
40995       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40996     } catch (std::out_of_range& e) {
40997       {
40998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40999       };
41000     } catch (std::exception& e) {
41001       {
41002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41003       };
41004     } catch (Dali::DaliException e) {
41005       {
41006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41007       };
41008     } catch (...) {
41009       {
41010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41011       };
41012     }
41013   }
41014
41015   jresult = result;
41016   return jresult;
41017 }
41018
41019
41020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41021   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41022   Dali::Radian arg2 ;
41023   Dali::Radian arg3 ;
41024   Dali::Radian *argp2 ;
41025   Dali::Radian *argp3 ;
41026
41027   arg1 = (Dali::PanGestureDetector *)jarg1;
41028   argp2 = (Dali::Radian *)jarg2;
41029   if (!argp2) {
41030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41031     return ;
41032   }
41033   arg2 = *argp2;
41034   argp3 = (Dali::Radian *)jarg3;
41035   if (!argp3) {
41036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41037     return ;
41038   }
41039   arg3 = *argp3;
41040   {
41041     try {
41042       (arg1)->AddAngle(arg2,arg3);
41043     } catch (std::out_of_range& e) {
41044       {
41045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41046       };
41047     } catch (std::exception& e) {
41048       {
41049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41050       };
41051     } catch (Dali::DaliException e) {
41052       {
41053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41054       };
41055     } catch (...) {
41056       {
41057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41058       };
41059     }
41060   }
41061
41062 }
41063
41064
41065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
41066   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41067   Dali::Radian arg2 ;
41068   Dali::Radian *argp2 ;
41069
41070   arg1 = (Dali::PanGestureDetector *)jarg1;
41071   argp2 = (Dali::Radian *)jarg2;
41072   if (!argp2) {
41073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41074     return ;
41075   }
41076   arg2 = *argp2;
41077   {
41078     try {
41079       (arg1)->AddAngle(arg2);
41080     } catch (std::out_of_range& e) {
41081       {
41082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41083       };
41084     } catch (std::exception& e) {
41085       {
41086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41087       };
41088     } catch (Dali::DaliException e) {
41089       {
41090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41091       };
41092     } catch (...) {
41093       {
41094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41095       };
41096     }
41097   }
41098
41099 }
41100
41101
41102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41103   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41104   Dali::Radian arg2 ;
41105   Dali::Radian arg3 ;
41106   Dali::Radian *argp2 ;
41107   Dali::Radian *argp3 ;
41108
41109   arg1 = (Dali::PanGestureDetector *)jarg1;
41110   argp2 = (Dali::Radian *)jarg2;
41111   if (!argp2) {
41112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41113     return ;
41114   }
41115   arg2 = *argp2;
41116   argp3 = (Dali::Radian *)jarg3;
41117   if (!argp3) {
41118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41119     return ;
41120   }
41121   arg3 = *argp3;
41122   {
41123     try {
41124       (arg1)->AddDirection(arg2,arg3);
41125     } catch (std::out_of_range& e) {
41126       {
41127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41128       };
41129     } catch (std::exception& e) {
41130       {
41131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41132       };
41133     } catch (Dali::DaliException e) {
41134       {
41135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41136       };
41137     } catch (...) {
41138       {
41139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41140       };
41141     }
41142   }
41143
41144 }
41145
41146
41147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41148   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41149   Dali::Radian arg2 ;
41150   Dali::Radian *argp2 ;
41151
41152   arg1 = (Dali::PanGestureDetector *)jarg1;
41153   argp2 = (Dali::Radian *)jarg2;
41154   if (!argp2) {
41155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41156     return ;
41157   }
41158   arg2 = *argp2;
41159   {
41160     try {
41161       (arg1)->AddDirection(arg2);
41162     } catch (std::out_of_range& e) {
41163       {
41164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41165       };
41166     } catch (std::exception& e) {
41167       {
41168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41169       };
41170     } catch (Dali::DaliException e) {
41171       {
41172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41173       };
41174     } catch (...) {
41175       {
41176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41177       };
41178     }
41179   }
41180
41181 }
41182
41183
41184 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41185   unsigned long jresult ;
41186   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41187   size_t result;
41188
41189   arg1 = (Dali::PanGestureDetector *)jarg1;
41190   {
41191     try {
41192       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41193     } catch (std::out_of_range& e) {
41194       {
41195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41196       };
41197     } catch (std::exception& e) {
41198       {
41199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41200       };
41201     } catch (Dali::DaliException e) {
41202       {
41203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41204       };
41205     } catch (...) {
41206       {
41207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41208       };
41209     }
41210   }
41211
41212   jresult = (unsigned long)result;
41213   return jresult;
41214 }
41215
41216
41217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41218   void * jresult ;
41219   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41220   size_t arg2 ;
41221   Dali::PanGestureDetector::AngleThresholdPair result;
41222
41223   arg1 = (Dali::PanGestureDetector *)jarg1;
41224   arg2 = (size_t)jarg2;
41225   {
41226     try {
41227       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41228     } catch (std::out_of_range& e) {
41229       {
41230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41231       };
41232     } catch (std::exception& e) {
41233       {
41234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41235       };
41236     } catch (Dali::DaliException e) {
41237       {
41238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41239       };
41240     } catch (...) {
41241       {
41242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41243       };
41244     }
41245   }
41246
41247   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41248   return jresult;
41249 }
41250
41251
41252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41253   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41254
41255   arg1 = (Dali::PanGestureDetector *)jarg1;
41256   {
41257     try {
41258       (arg1)->ClearAngles();
41259     } catch (std::out_of_range& e) {
41260       {
41261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41262       };
41263     } catch (std::exception& e) {
41264       {
41265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41266       };
41267     } catch (Dali::DaliException e) {
41268       {
41269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41270       };
41271     } catch (...) {
41272       {
41273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41274       };
41275     }
41276   }
41277
41278 }
41279
41280
41281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41282   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41283   Dali::Radian arg2 ;
41284   Dali::Radian *argp2 ;
41285
41286   arg1 = (Dali::PanGestureDetector *)jarg1;
41287   argp2 = (Dali::Radian *)jarg2;
41288   if (!argp2) {
41289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41290     return ;
41291   }
41292   arg2 = *argp2;
41293   {
41294     try {
41295       (arg1)->RemoveAngle(arg2);
41296     } catch (std::out_of_range& e) {
41297       {
41298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41299       };
41300     } catch (std::exception& e) {
41301       {
41302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41303       };
41304     } catch (Dali::DaliException e) {
41305       {
41306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41307       };
41308     } catch (...) {
41309       {
41310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41311       };
41312     }
41313   }
41314
41315 }
41316
41317
41318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41319   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41320   Dali::Radian arg2 ;
41321   Dali::Radian *argp2 ;
41322
41323   arg1 = (Dali::PanGestureDetector *)jarg1;
41324   argp2 = (Dali::Radian *)jarg2;
41325   if (!argp2) {
41326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41327     return ;
41328   }
41329   arg2 = *argp2;
41330   {
41331     try {
41332       (arg1)->RemoveDirection(arg2);
41333     } catch (std::out_of_range& e) {
41334       {
41335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41336       };
41337     } catch (std::exception& e) {
41338       {
41339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41340       };
41341     } catch (Dali::DaliException e) {
41342       {
41343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41344       };
41345     } catch (...) {
41346       {
41347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41348       };
41349     }
41350   }
41351
41352 }
41353
41354
41355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41356   void * jresult ;
41357   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41358   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41359
41360   arg1 = (Dali::PanGestureDetector *)jarg1;
41361   {
41362     try {
41363       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41364     } catch (std::out_of_range& e) {
41365       {
41366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41367       };
41368     } catch (std::exception& e) {
41369       {
41370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41371       };
41372     } catch (Dali::DaliException e) {
41373       {
41374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41375       };
41376     } catch (...) {
41377       {
41378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41379       };
41380     }
41381   }
41382
41383   jresult = (void *)result;
41384   return jresult;
41385 }
41386
41387
41388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41389   Dali::PanGesture *arg1 = 0 ;
41390
41391   arg1 = (Dali::PanGesture *)jarg1;
41392   if (!arg1) {
41393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41394     return ;
41395   }
41396   {
41397     try {
41398       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41399     } catch (std::out_of_range& e) {
41400       {
41401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41402       };
41403     } catch (std::exception& e) {
41404       {
41405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41406       };
41407     } catch (Dali::DaliException e) {
41408       {
41409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41410       };
41411     } catch (...) {
41412       {
41413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41414       };
41415     }
41416   }
41417
41418 }
41419
41420
41421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41422   void * jresult ;
41423   Dali::PanGesture *result = 0 ;
41424
41425   {
41426     try {
41427       result = (Dali::PanGesture *)new Dali::PanGesture();
41428     } catch (std::out_of_range& e) {
41429       {
41430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41431       };
41432     } catch (std::exception& e) {
41433       {
41434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41435       };
41436     } catch (Dali::DaliException e) {
41437       {
41438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41439       };
41440     } catch (...) {
41441       {
41442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41443       };
41444     }
41445   }
41446
41447   jresult = (void *)result;
41448   return jresult;
41449 }
41450
41451
41452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41453   void * jresult ;
41454   Dali::Gesture::State arg1 ;
41455   Dali::PanGesture *result = 0 ;
41456
41457   arg1 = (Dali::Gesture::State)jarg1;
41458   {
41459     try {
41460       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41461     } catch (std::out_of_range& e) {
41462       {
41463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41464       };
41465     } catch (std::exception& e) {
41466       {
41467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41468       };
41469     } catch (Dali::DaliException e) {
41470       {
41471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41472       };
41473     } catch (...) {
41474       {
41475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41476       };
41477     }
41478   }
41479
41480   jresult = (void *)result;
41481   return jresult;
41482 }
41483
41484
41485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41486   void * jresult ;
41487   Dali::PanGesture *arg1 = 0 ;
41488   Dali::PanGesture *result = 0 ;
41489
41490   arg1 = (Dali::PanGesture *)jarg1;
41491   if (!arg1) {
41492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41493     return 0;
41494   }
41495   {
41496     try {
41497       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41498     } catch (std::out_of_range& e) {
41499       {
41500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41501       };
41502     } catch (std::exception& e) {
41503       {
41504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41505       };
41506     } catch (Dali::DaliException e) {
41507       {
41508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41509       };
41510     } catch (...) {
41511       {
41512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41513       };
41514     }
41515   }
41516
41517   jresult = (void *)result;
41518   return jresult;
41519 }
41520
41521
41522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41523   void * jresult ;
41524   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41525   Dali::PanGesture *arg2 = 0 ;
41526   Dali::PanGesture *result = 0 ;
41527
41528   arg1 = (Dali::PanGesture *)jarg1;
41529   arg2 = (Dali::PanGesture *)jarg2;
41530   if (!arg2) {
41531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41532     return 0;
41533   }
41534   {
41535     try {
41536       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41537     } catch (std::out_of_range& e) {
41538       {
41539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41540       };
41541     } catch (std::exception& e) {
41542       {
41543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41544       };
41545     } catch (Dali::DaliException e) {
41546       {
41547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41548       };
41549     } catch (...) {
41550       {
41551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41552       };
41553     }
41554   }
41555
41556   jresult = (void *)result;
41557   return jresult;
41558 }
41559
41560
41561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41562   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41563
41564   arg1 = (Dali::PanGesture *)jarg1;
41565   {
41566     try {
41567       delete arg1;
41568     } catch (std::out_of_range& e) {
41569       {
41570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41571       };
41572     } catch (std::exception& e) {
41573       {
41574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41575       };
41576     } catch (Dali::DaliException e) {
41577       {
41578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41579       };
41580     } catch (...) {
41581       {
41582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41583       };
41584     }
41585   }
41586
41587 }
41588
41589
41590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41591   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41592   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41593
41594   arg1 = (Dali::PanGesture *)jarg1;
41595   arg2 = (Dali::Vector2 *)jarg2;
41596   if (arg1) (arg1)->velocity = *arg2;
41597 }
41598
41599
41600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41601   void * jresult ;
41602   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41603   Dali::Vector2 *result = 0 ;
41604
41605   arg1 = (Dali::PanGesture *)jarg1;
41606   result = (Dali::Vector2 *)& ((arg1)->velocity);
41607   jresult = (void *)result;
41608   return jresult;
41609 }
41610
41611
41612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41613   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41614   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41615
41616   arg1 = (Dali::PanGesture *)jarg1;
41617   arg2 = (Dali::Vector2 *)jarg2;
41618   if (arg1) (arg1)->displacement = *arg2;
41619 }
41620
41621
41622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41623   void * jresult ;
41624   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41625   Dali::Vector2 *result = 0 ;
41626
41627   arg1 = (Dali::PanGesture *)jarg1;
41628   result = (Dali::Vector2 *)& ((arg1)->displacement);
41629   jresult = (void *)result;
41630   return jresult;
41631 }
41632
41633
41634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41635   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41636   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41637
41638   arg1 = (Dali::PanGesture *)jarg1;
41639   arg2 = (Dali::Vector2 *)jarg2;
41640   if (arg1) (arg1)->position = *arg2;
41641 }
41642
41643
41644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41645   void * jresult ;
41646   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41647   Dali::Vector2 *result = 0 ;
41648
41649   arg1 = (Dali::PanGesture *)jarg1;
41650   result = (Dali::Vector2 *)& ((arg1)->position);
41651   jresult = (void *)result;
41652   return jresult;
41653 }
41654
41655
41656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41657   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41658   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41659
41660   arg1 = (Dali::PanGesture *)jarg1;
41661   arg2 = (Dali::Vector2 *)jarg2;
41662   if (arg1) (arg1)->screenVelocity = *arg2;
41663 }
41664
41665
41666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41667   void * jresult ;
41668   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41669   Dali::Vector2 *result = 0 ;
41670
41671   arg1 = (Dali::PanGesture *)jarg1;
41672   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41673   jresult = (void *)result;
41674   return jresult;
41675 }
41676
41677
41678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41679   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41680   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41681
41682   arg1 = (Dali::PanGesture *)jarg1;
41683   arg2 = (Dali::Vector2 *)jarg2;
41684   if (arg1) (arg1)->screenDisplacement = *arg2;
41685 }
41686
41687
41688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41689   void * jresult ;
41690   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41691   Dali::Vector2 *result = 0 ;
41692
41693   arg1 = (Dali::PanGesture *)jarg1;
41694   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41695   jresult = (void *)result;
41696   return jresult;
41697 }
41698
41699
41700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41701   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41702   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41703
41704   arg1 = (Dali::PanGesture *)jarg1;
41705   arg2 = (Dali::Vector2 *)jarg2;
41706   if (arg1) (arg1)->screenPosition = *arg2;
41707 }
41708
41709
41710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41711   void * jresult ;
41712   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41713   Dali::Vector2 *result = 0 ;
41714
41715   arg1 = (Dali::PanGesture *)jarg1;
41716   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41717   jresult = (void *)result;
41718   return jresult;
41719 }
41720
41721
41722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41723   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41724   unsigned int arg2 ;
41725
41726   arg1 = (Dali::PanGesture *)jarg1;
41727   arg2 = (unsigned int)jarg2;
41728   if (arg1) (arg1)->numberOfTouches = arg2;
41729 }
41730
41731
41732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41733   unsigned int jresult ;
41734   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41735   unsigned int result;
41736
41737   arg1 = (Dali::PanGesture *)jarg1;
41738   result = (unsigned int) ((arg1)->numberOfTouches);
41739   jresult = result;
41740   return jresult;
41741 }
41742
41743
41744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41745   float jresult ;
41746   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41747   float result;
41748
41749   arg1 = (Dali::PanGesture *)jarg1;
41750   {
41751     try {
41752       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41753     } catch (std::out_of_range& e) {
41754       {
41755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (std::exception& e) {
41758       {
41759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (Dali::DaliException e) {
41762       {
41763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41764       };
41765     } catch (...) {
41766       {
41767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41768       };
41769     }
41770   }
41771
41772   jresult = result;
41773   return jresult;
41774 }
41775
41776
41777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41778   float jresult ;
41779   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41780   float result;
41781
41782   arg1 = (Dali::PanGesture *)jarg1;
41783   {
41784     try {
41785       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41786     } catch (std::out_of_range& e) {
41787       {
41788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41789       };
41790     } catch (std::exception& e) {
41791       {
41792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41793       };
41794     } catch (Dali::DaliException e) {
41795       {
41796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41797       };
41798     } catch (...) {
41799       {
41800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41801       };
41802     }
41803   }
41804
41805   jresult = result;
41806   return jresult;
41807 }
41808
41809
41810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41811   float jresult ;
41812   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41813   float result;
41814
41815   arg1 = (Dali::PanGesture *)jarg1;
41816   {
41817     try {
41818       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41819     } catch (std::out_of_range& e) {
41820       {
41821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41822       };
41823     } catch (std::exception& e) {
41824       {
41825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41826       };
41827     } catch (Dali::DaliException e) {
41828       {
41829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41830       };
41831     } catch (...) {
41832       {
41833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41834       };
41835     }
41836   }
41837
41838   jresult = result;
41839   return jresult;
41840 }
41841
41842
41843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41844   float jresult ;
41845   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41846   float result;
41847
41848   arg1 = (Dali::PanGesture *)jarg1;
41849   {
41850     try {
41851       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41852     } catch (std::out_of_range& e) {
41853       {
41854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41855       };
41856     } catch (std::exception& e) {
41857       {
41858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41859       };
41860     } catch (Dali::DaliException e) {
41861       {
41862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41863       };
41864     } catch (...) {
41865       {
41866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41867       };
41868     }
41869   }
41870
41871   jresult = result;
41872   return jresult;
41873 }
41874
41875
41876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41877   void * jresult ;
41878   Dali::PinchGestureDetector *result = 0 ;
41879
41880   {
41881     try {
41882       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41883     } catch (std::out_of_range& e) {
41884       {
41885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41886       };
41887     } catch (std::exception& e) {
41888       {
41889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41890       };
41891     } catch (Dali::DaliException e) {
41892       {
41893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41894       };
41895     } catch (...) {
41896       {
41897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41898       };
41899     }
41900   }
41901
41902   jresult = (void *)result;
41903   return jresult;
41904 }
41905
41906
41907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41908   void * jresult ;
41909   Dali::PinchGestureDetector result;
41910
41911   {
41912     try {
41913       result = Dali::PinchGestureDetector::New();
41914     } catch (std::out_of_range& e) {
41915       {
41916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41917       };
41918     } catch (std::exception& e) {
41919       {
41920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41921       };
41922     } catch (Dali::DaliException e) {
41923       {
41924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41925       };
41926     } catch (...) {
41927       {
41928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41929       };
41930     }
41931   }
41932
41933   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41934   return jresult;
41935 }
41936
41937
41938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41939   void * jresult ;
41940   Dali::BaseHandle arg1 ;
41941   Dali::BaseHandle *argp1 ;
41942   Dali::PinchGestureDetector result;
41943
41944   argp1 = (Dali::BaseHandle *)jarg1;
41945   if (!argp1) {
41946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41947     return 0;
41948   }
41949   arg1 = *argp1;
41950   {
41951     try {
41952       result = Dali::PinchGestureDetector::DownCast(arg1);
41953     } catch (std::out_of_range& e) {
41954       {
41955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41956       };
41957     } catch (std::exception& e) {
41958       {
41959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41960       };
41961     } catch (Dali::DaliException e) {
41962       {
41963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41964       };
41965     } catch (...) {
41966       {
41967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41968       };
41969     }
41970   }
41971
41972   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41973   return jresult;
41974 }
41975
41976
41977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41978   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41979
41980   arg1 = (Dali::PinchGestureDetector *)jarg1;
41981   {
41982     try {
41983       delete arg1;
41984     } catch (std::out_of_range& e) {
41985       {
41986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41987       };
41988     } catch (std::exception& e) {
41989       {
41990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41991       };
41992     } catch (Dali::DaliException e) {
41993       {
41994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41995       };
41996     } catch (...) {
41997       {
41998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41999       };
42000     }
42001   }
42002
42003 }
42004
42005
42006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
42007   void * jresult ;
42008   Dali::PinchGestureDetector *arg1 = 0 ;
42009   Dali::PinchGestureDetector *result = 0 ;
42010
42011   arg1 = (Dali::PinchGestureDetector *)jarg1;
42012   if (!arg1) {
42013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42014     return 0;
42015   }
42016   {
42017     try {
42018       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
42019     } catch (std::out_of_range& e) {
42020       {
42021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42022       };
42023     } catch (std::exception& e) {
42024       {
42025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42026       };
42027     } catch (Dali::DaliException e) {
42028       {
42029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42030       };
42031     } catch (...) {
42032       {
42033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42034       };
42035     }
42036   }
42037
42038   jresult = (void *)result;
42039   return jresult;
42040 }
42041
42042
42043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
42044   void * jresult ;
42045   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42046   Dali::PinchGestureDetector *arg2 = 0 ;
42047   Dali::PinchGestureDetector *result = 0 ;
42048
42049   arg1 = (Dali::PinchGestureDetector *)jarg1;
42050   arg2 = (Dali::PinchGestureDetector *)jarg2;
42051   if (!arg2) {
42052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42053     return 0;
42054   }
42055   {
42056     try {
42057       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
42058     } catch (std::out_of_range& e) {
42059       {
42060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42061       };
42062     } catch (std::exception& e) {
42063       {
42064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42065       };
42066     } catch (Dali::DaliException e) {
42067       {
42068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42069       };
42070     } catch (...) {
42071       {
42072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42073       };
42074     }
42075   }
42076
42077   jresult = (void *)result;
42078   return jresult;
42079 }
42080
42081
42082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42083   void * jresult ;
42084   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42085   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42086
42087   arg1 = (Dali::PinchGestureDetector *)jarg1;
42088   {
42089     try {
42090       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42091     } catch (std::out_of_range& e) {
42092       {
42093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42094       };
42095     } catch (std::exception& e) {
42096       {
42097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42098       };
42099     } catch (Dali::DaliException e) {
42100       {
42101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42102       };
42103     } catch (...) {
42104       {
42105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42106       };
42107     }
42108   }
42109
42110   jresult = (void *)result;
42111   return jresult;
42112 }
42113
42114
42115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42116   void * jresult ;
42117   Dali::Gesture::State arg1 ;
42118   Dali::PinchGesture *result = 0 ;
42119
42120   arg1 = (Dali::Gesture::State)jarg1;
42121   {
42122     try {
42123       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42124     } catch (std::out_of_range& e) {
42125       {
42126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42127       };
42128     } catch (std::exception& e) {
42129       {
42130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42131       };
42132     } catch (Dali::DaliException e) {
42133       {
42134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42135       };
42136     } catch (...) {
42137       {
42138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42139       };
42140     }
42141   }
42142
42143   jresult = (void *)result;
42144   return jresult;
42145 }
42146
42147
42148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42149   void * jresult ;
42150   Dali::PinchGesture *arg1 = 0 ;
42151   Dali::PinchGesture *result = 0 ;
42152
42153   arg1 = (Dali::PinchGesture *)jarg1;
42154   if (!arg1) {
42155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42156     return 0;
42157   }
42158   {
42159     try {
42160       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42161     } catch (std::out_of_range& e) {
42162       {
42163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42164       };
42165     } catch (std::exception& e) {
42166       {
42167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42168       };
42169     } catch (Dali::DaliException e) {
42170       {
42171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42172       };
42173     } catch (...) {
42174       {
42175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42176       };
42177     }
42178   }
42179
42180   jresult = (void *)result;
42181   return jresult;
42182 }
42183
42184
42185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42186   void * jresult ;
42187   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42188   Dali::PinchGesture *arg2 = 0 ;
42189   Dali::PinchGesture *result = 0 ;
42190
42191   arg1 = (Dali::PinchGesture *)jarg1;
42192   arg2 = (Dali::PinchGesture *)jarg2;
42193   if (!arg2) {
42194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42195     return 0;
42196   }
42197   {
42198     try {
42199       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42200     } catch (std::out_of_range& e) {
42201       {
42202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42203       };
42204     } catch (std::exception& e) {
42205       {
42206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42207       };
42208     } catch (Dali::DaliException e) {
42209       {
42210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42211       };
42212     } catch (...) {
42213       {
42214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42215       };
42216     }
42217   }
42218
42219   jresult = (void *)result;
42220   return jresult;
42221 }
42222
42223
42224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42225   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42226
42227   arg1 = (Dali::PinchGesture *)jarg1;
42228   {
42229     try {
42230       delete arg1;
42231     } catch (std::out_of_range& e) {
42232       {
42233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42234       };
42235     } catch (std::exception& e) {
42236       {
42237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42238       };
42239     } catch (Dali::DaliException e) {
42240       {
42241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42242       };
42243     } catch (...) {
42244       {
42245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42246       };
42247     }
42248   }
42249
42250 }
42251
42252
42253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42254   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42255   float arg2 ;
42256
42257   arg1 = (Dali::PinchGesture *)jarg1;
42258   arg2 = (float)jarg2;
42259   if (arg1) (arg1)->scale = arg2;
42260 }
42261
42262
42263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42264   float jresult ;
42265   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42266   float result;
42267
42268   arg1 = (Dali::PinchGesture *)jarg1;
42269   result = (float) ((arg1)->scale);
42270   jresult = result;
42271   return jresult;
42272 }
42273
42274
42275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42276   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42277   float arg2 ;
42278
42279   arg1 = (Dali::PinchGesture *)jarg1;
42280   arg2 = (float)jarg2;
42281   if (arg1) (arg1)->speed = arg2;
42282 }
42283
42284
42285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42286   float jresult ;
42287   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42288   float result;
42289
42290   arg1 = (Dali::PinchGesture *)jarg1;
42291   result = (float) ((arg1)->speed);
42292   jresult = result;
42293   return jresult;
42294 }
42295
42296
42297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42298   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42299   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42300
42301   arg1 = (Dali::PinchGesture *)jarg1;
42302   arg2 = (Dali::Vector2 *)jarg2;
42303   if (arg1) (arg1)->screenCenterPoint = *arg2;
42304 }
42305
42306
42307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42308   void * jresult ;
42309   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42310   Dali::Vector2 *result = 0 ;
42311
42312   arg1 = (Dali::PinchGesture *)jarg1;
42313   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42314   jresult = (void *)result;
42315   return jresult;
42316 }
42317
42318
42319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42320   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42321   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42322
42323   arg1 = (Dali::PinchGesture *)jarg1;
42324   arg2 = (Dali::Vector2 *)jarg2;
42325   if (arg1) (arg1)->localCenterPoint = *arg2;
42326 }
42327
42328
42329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42330   void * jresult ;
42331   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42332   Dali::Vector2 *result = 0 ;
42333
42334   arg1 = (Dali::PinchGesture *)jarg1;
42335   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42336   jresult = (void *)result;
42337   return jresult;
42338 }
42339
42340
42341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42342   void * jresult ;
42343   Dali::TapGestureDetector *result = 0 ;
42344
42345   {
42346     try {
42347       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42348     } catch (std::out_of_range& e) {
42349       {
42350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42351       };
42352     } catch (std::exception& e) {
42353       {
42354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42355       };
42356     } catch (Dali::DaliException e) {
42357       {
42358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42359       };
42360     } catch (...) {
42361       {
42362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42363       };
42364     }
42365   }
42366
42367   jresult = (void *)result;
42368   return jresult;
42369 }
42370
42371
42372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42373   void * jresult ;
42374   Dali::TapGestureDetector result;
42375
42376   {
42377     try {
42378       result = Dali::TapGestureDetector::New();
42379     } catch (std::out_of_range& e) {
42380       {
42381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42382       };
42383     } catch (std::exception& e) {
42384       {
42385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42386       };
42387     } catch (Dali::DaliException e) {
42388       {
42389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42390       };
42391     } catch (...) {
42392       {
42393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42394       };
42395     }
42396   }
42397
42398   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42399   return jresult;
42400 }
42401
42402
42403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42404   void * jresult ;
42405   unsigned int arg1 ;
42406   Dali::TapGestureDetector result;
42407
42408   arg1 = (unsigned int)jarg1;
42409   {
42410     try {
42411       result = Dali::TapGestureDetector::New(arg1);
42412     } catch (std::out_of_range& e) {
42413       {
42414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42415       };
42416     } catch (std::exception& e) {
42417       {
42418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42419       };
42420     } catch (Dali::DaliException e) {
42421       {
42422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42423       };
42424     } catch (...) {
42425       {
42426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42427       };
42428     }
42429   }
42430
42431   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42432   return jresult;
42433 }
42434
42435
42436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42437   void * jresult ;
42438   Dali::BaseHandle arg1 ;
42439   Dali::BaseHandle *argp1 ;
42440   Dali::TapGestureDetector result;
42441
42442   argp1 = (Dali::BaseHandle *)jarg1;
42443   if (!argp1) {
42444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42445     return 0;
42446   }
42447   arg1 = *argp1;
42448   {
42449     try {
42450       result = Dali::TapGestureDetector::DownCast(arg1);
42451     } catch (std::out_of_range& e) {
42452       {
42453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42454       };
42455     } catch (std::exception& e) {
42456       {
42457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42458       };
42459     } catch (Dali::DaliException e) {
42460       {
42461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42462       };
42463     } catch (...) {
42464       {
42465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42466       };
42467     }
42468   }
42469
42470   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42471   return jresult;
42472 }
42473
42474
42475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42476   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42477
42478   arg1 = (Dali::TapGestureDetector *)jarg1;
42479   {
42480     try {
42481       delete arg1;
42482     } catch (std::out_of_range& e) {
42483       {
42484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42485       };
42486     } catch (std::exception& e) {
42487       {
42488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42489       };
42490     } catch (Dali::DaliException e) {
42491       {
42492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42493       };
42494     } catch (...) {
42495       {
42496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42497       };
42498     }
42499   }
42500
42501 }
42502
42503
42504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42505   void * jresult ;
42506   Dali::TapGestureDetector *arg1 = 0 ;
42507   Dali::TapGestureDetector *result = 0 ;
42508
42509   arg1 = (Dali::TapGestureDetector *)jarg1;
42510   if (!arg1) {
42511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42512     return 0;
42513   }
42514   {
42515     try {
42516       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42517     } catch (std::out_of_range& e) {
42518       {
42519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42520       };
42521     } catch (std::exception& e) {
42522       {
42523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42524       };
42525     } catch (Dali::DaliException e) {
42526       {
42527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42528       };
42529     } catch (...) {
42530       {
42531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42532       };
42533     }
42534   }
42535
42536   jresult = (void *)result;
42537   return jresult;
42538 }
42539
42540
42541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42542   void * jresult ;
42543   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42544   Dali::TapGestureDetector *arg2 = 0 ;
42545   Dali::TapGestureDetector *result = 0 ;
42546
42547   arg1 = (Dali::TapGestureDetector *)jarg1;
42548   arg2 = (Dali::TapGestureDetector *)jarg2;
42549   if (!arg2) {
42550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42551     return 0;
42552   }
42553   {
42554     try {
42555       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42556     } catch (std::out_of_range& e) {
42557       {
42558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42559       };
42560     } catch (std::exception& e) {
42561       {
42562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42563       };
42564     } catch (Dali::DaliException e) {
42565       {
42566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42567       };
42568     } catch (...) {
42569       {
42570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42571       };
42572     }
42573   }
42574
42575   jresult = (void *)result;
42576   return jresult;
42577 }
42578
42579
42580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42581   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42582   unsigned int arg2 ;
42583
42584   arg1 = (Dali::TapGestureDetector *)jarg1;
42585   arg2 = (unsigned int)jarg2;
42586   {
42587     try {
42588       (arg1)->SetMinimumTapsRequired(arg2);
42589     } catch (std::out_of_range& e) {
42590       {
42591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42592       };
42593     } catch (std::exception& e) {
42594       {
42595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42596       };
42597     } catch (Dali::DaliException e) {
42598       {
42599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42600       };
42601     } catch (...) {
42602       {
42603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42604       };
42605     }
42606   }
42607
42608 }
42609
42610
42611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42612   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42613   unsigned int arg2 ;
42614
42615   arg1 = (Dali::TapGestureDetector *)jarg1;
42616   arg2 = (unsigned int)jarg2;
42617   {
42618     try {
42619       (arg1)->SetMaximumTapsRequired(arg2);
42620     } catch (std::out_of_range& e) {
42621       {
42622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42623       };
42624     } catch (std::exception& e) {
42625       {
42626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42627       };
42628     } catch (Dali::DaliException e) {
42629       {
42630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42631       };
42632     } catch (...) {
42633       {
42634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42635       };
42636     }
42637   }
42638
42639 }
42640
42641
42642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42643   unsigned int jresult ;
42644   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42645   unsigned int result;
42646
42647   arg1 = (Dali::TapGestureDetector *)jarg1;
42648   {
42649     try {
42650       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42651     } catch (std::out_of_range& e) {
42652       {
42653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42654       };
42655     } catch (std::exception& e) {
42656       {
42657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42658       };
42659     } catch (Dali::DaliException e) {
42660       {
42661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42662       };
42663     } catch (...) {
42664       {
42665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42666       };
42667     }
42668   }
42669
42670   jresult = result;
42671   return jresult;
42672 }
42673
42674
42675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42676   unsigned int jresult ;
42677   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42678   unsigned int result;
42679
42680   arg1 = (Dali::TapGestureDetector *)jarg1;
42681   {
42682     try {
42683       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42684     } catch (std::out_of_range& e) {
42685       {
42686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42687       };
42688     } catch (std::exception& e) {
42689       {
42690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42691       };
42692     } catch (Dali::DaliException e) {
42693       {
42694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42695       };
42696     } catch (...) {
42697       {
42698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42699       };
42700     }
42701   }
42702
42703   jresult = result;
42704   return jresult;
42705 }
42706
42707
42708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42709   void * jresult ;
42710   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42711   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42712
42713   arg1 = (Dali::TapGestureDetector *)jarg1;
42714   {
42715     try {
42716       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42717     } catch (std::out_of_range& e) {
42718       {
42719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42720       };
42721     } catch (std::exception& e) {
42722       {
42723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42724       };
42725     } catch (Dali::DaliException e) {
42726       {
42727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42728       };
42729     } catch (...) {
42730       {
42731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42732       };
42733     }
42734   }
42735
42736   jresult = (void *)result;
42737   return jresult;
42738 }
42739
42740
42741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42742   void * jresult ;
42743   Dali::TapGesture *result = 0 ;
42744
42745   {
42746     try {
42747       result = (Dali::TapGesture *)new Dali::TapGesture();
42748     } catch (std::out_of_range& e) {
42749       {
42750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42751       };
42752     } catch (std::exception& e) {
42753       {
42754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42755       };
42756     } catch (Dali::DaliException e) {
42757       {
42758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42759       };
42760     } catch (...) {
42761       {
42762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42763       };
42764     }
42765   }
42766
42767   jresult = (void *)result;
42768   return jresult;
42769 }
42770
42771
42772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42773   void * jresult ;
42774   Dali::TapGesture *arg1 = 0 ;
42775   Dali::TapGesture *result = 0 ;
42776
42777   arg1 = (Dali::TapGesture *)jarg1;
42778   if (!arg1) {
42779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42780     return 0;
42781   }
42782   {
42783     try {
42784       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42785     } catch (std::out_of_range& e) {
42786       {
42787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42788       };
42789     } catch (std::exception& e) {
42790       {
42791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42792       };
42793     } catch (Dali::DaliException e) {
42794       {
42795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42796       };
42797     } catch (...) {
42798       {
42799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42800       };
42801     }
42802   }
42803
42804   jresult = (void *)result;
42805   return jresult;
42806 }
42807
42808
42809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42810   void * jresult ;
42811   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42812   Dali::TapGesture *arg2 = 0 ;
42813   Dali::TapGesture *result = 0 ;
42814
42815   arg1 = (Dali::TapGesture *)jarg1;
42816   arg2 = (Dali::TapGesture *)jarg2;
42817   if (!arg2) {
42818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42819     return 0;
42820   }
42821   {
42822     try {
42823       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42824     } catch (std::out_of_range& e) {
42825       {
42826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42827       };
42828     } catch (std::exception& e) {
42829       {
42830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42831       };
42832     } catch (Dali::DaliException e) {
42833       {
42834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42835       };
42836     } catch (...) {
42837       {
42838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42839       };
42840     }
42841   }
42842
42843   jresult = (void *)result;
42844   return jresult;
42845 }
42846
42847
42848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42849   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42850
42851   arg1 = (Dali::TapGesture *)jarg1;
42852   {
42853     try {
42854       delete arg1;
42855     } catch (std::out_of_range& e) {
42856       {
42857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42858       };
42859     } catch (std::exception& e) {
42860       {
42861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42862       };
42863     } catch (Dali::DaliException e) {
42864       {
42865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42866       };
42867     } catch (...) {
42868       {
42869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42870       };
42871     }
42872   }
42873
42874 }
42875
42876
42877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42878   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42879   unsigned int arg2 ;
42880
42881   arg1 = (Dali::TapGesture *)jarg1;
42882   arg2 = (unsigned int)jarg2;
42883   if (arg1) (arg1)->numberOfTaps = arg2;
42884 }
42885
42886
42887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42888   unsigned int jresult ;
42889   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42890   unsigned int result;
42891
42892   arg1 = (Dali::TapGesture *)jarg1;
42893   result = (unsigned int) ((arg1)->numberOfTaps);
42894   jresult = result;
42895   return jresult;
42896 }
42897
42898
42899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42900   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42901   unsigned int arg2 ;
42902
42903   arg1 = (Dali::TapGesture *)jarg1;
42904   arg2 = (unsigned int)jarg2;
42905   if (arg1) (arg1)->numberOfTouches = arg2;
42906 }
42907
42908
42909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42910   unsigned int jresult ;
42911   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42912   unsigned int result;
42913
42914   arg1 = (Dali::TapGesture *)jarg1;
42915   result = (unsigned int) ((arg1)->numberOfTouches);
42916   jresult = result;
42917   return jresult;
42918 }
42919
42920
42921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42922   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42923   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42924
42925   arg1 = (Dali::TapGesture *)jarg1;
42926   arg2 = (Dali::Vector2 *)jarg2;
42927   if (arg1) (arg1)->screenPoint = *arg2;
42928 }
42929
42930
42931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42932   void * jresult ;
42933   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42934   Dali::Vector2 *result = 0 ;
42935
42936   arg1 = (Dali::TapGesture *)jarg1;
42937   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42938   jresult = (void *)result;
42939   return jresult;
42940 }
42941
42942
42943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42944   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42945   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42946
42947   arg1 = (Dali::TapGesture *)jarg1;
42948   arg2 = (Dali::Vector2 *)jarg2;
42949   if (arg1) (arg1)->localPoint = *arg2;
42950 }
42951
42952
42953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42954   void * jresult ;
42955   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42956   Dali::Vector2 *result = 0 ;
42957
42958   arg1 = (Dali::TapGesture *)jarg1;
42959   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42960   jresult = (void *)result;
42961   return jresult;
42962 }
42963
42964
42965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42966   void * jresult ;
42967   Dali::AlphaFunction *result = 0 ;
42968
42969   {
42970     try {
42971       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42972     } catch (std::out_of_range& e) {
42973       {
42974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42975       };
42976     } catch (std::exception& e) {
42977       {
42978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42979       };
42980     } catch (Dali::DaliException e) {
42981       {
42982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42983       };
42984     } catch (...) {
42985       {
42986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42987       };
42988     }
42989   }
42990
42991   jresult = (void *)result;
42992   return jresult;
42993 }
42994
42995
42996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42997   void * jresult ;
42998   Dali::AlphaFunction::BuiltinFunction arg1 ;
42999   Dali::AlphaFunction *result = 0 ;
43000
43001   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
43002   {
43003     try {
43004       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43005     } catch (std::out_of_range& e) {
43006       {
43007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43008       };
43009     } catch (std::exception& e) {
43010       {
43011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43012       };
43013     } catch (Dali::DaliException e) {
43014       {
43015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43016       };
43017     } catch (...) {
43018       {
43019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43020       };
43021     }
43022   }
43023
43024   jresult = (void *)result;
43025   return jresult;
43026 }
43027
43028
43029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
43030   void * jresult ;
43031   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
43032   Dali::AlphaFunction *result = 0 ;
43033
43034   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
43035   {
43036     try {
43037       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43038     } catch (std::out_of_range& e) {
43039       {
43040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43041       };
43042     } catch (std::exception& e) {
43043       {
43044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43045       };
43046     } catch (Dali::DaliException e) {
43047       {
43048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43049       };
43050     } catch (...) {
43051       {
43052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43053       };
43054     }
43055   }
43056
43057   jresult = (void *)result;
43058   return jresult;
43059 }
43060
43061
43062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
43063   void * jresult ;
43064   Dali::Vector2 *arg1 = 0 ;
43065   Dali::Vector2 *arg2 = 0 ;
43066   Dali::AlphaFunction *result = 0 ;
43067
43068   arg1 = (Dali::Vector2 *)jarg1;
43069   if (!arg1) {
43070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43071     return 0;
43072   }
43073   arg2 = (Dali::Vector2 *)jarg2;
43074   if (!arg2) {
43075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43076     return 0;
43077   }
43078   {
43079     try {
43080       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43081     } catch (std::out_of_range& e) {
43082       {
43083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43084       };
43085     } catch (std::exception& e) {
43086       {
43087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43088       };
43089     } catch (Dali::DaliException e) {
43090       {
43091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43092       };
43093     } catch (...) {
43094       {
43095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43096       };
43097     }
43098   }
43099
43100   jresult = (void *)result;
43101   return jresult;
43102 }
43103
43104
43105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43106   void * jresult ;
43107   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43108   Dali::Vector4 result;
43109
43110   arg1 = (Dali::AlphaFunction *)jarg1;
43111   {
43112     try {
43113       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43114     } catch (std::out_of_range& e) {
43115       {
43116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43117       };
43118     } catch (std::exception& e) {
43119       {
43120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43121       };
43122     } catch (Dali::DaliException e) {
43123       {
43124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43125       };
43126     } catch (...) {
43127       {
43128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43129       };
43130     }
43131   }
43132
43133   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43134   return jresult;
43135 }
43136
43137
43138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43139   void * jresult ;
43140   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43141   Dali::AlphaFunctionPrototype result;
43142
43143   arg1 = (Dali::AlphaFunction *)jarg1;
43144   {
43145     try {
43146       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43147     } catch (std::out_of_range& e) {
43148       {
43149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43150       };
43151     } catch (std::exception& e) {
43152       {
43153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43154       };
43155     } catch (Dali::DaliException e) {
43156       {
43157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43158       };
43159     } catch (...) {
43160       {
43161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43162       };
43163     }
43164   }
43165
43166   jresult = (void *)result;
43167   return jresult;
43168 }
43169
43170
43171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43172   int jresult ;
43173   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43174   Dali::AlphaFunction::BuiltinFunction result;
43175
43176   arg1 = (Dali::AlphaFunction *)jarg1;
43177   {
43178     try {
43179       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43180     } catch (std::out_of_range& e) {
43181       {
43182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43183       };
43184     } catch (std::exception& e) {
43185       {
43186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43187       };
43188     } catch (Dali::DaliException e) {
43189       {
43190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43191       };
43192     } catch (...) {
43193       {
43194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43195       };
43196     }
43197   }
43198
43199   jresult = (int)result;
43200   return jresult;
43201 }
43202
43203
43204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43205   int jresult ;
43206   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43207   Dali::AlphaFunction::Mode result;
43208
43209   arg1 = (Dali::AlphaFunction *)jarg1;
43210   {
43211     try {
43212       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43213     } catch (std::out_of_range& e) {
43214       {
43215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43216       };
43217     } catch (std::exception& e) {
43218       {
43219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43220       };
43221     } catch (Dali::DaliException e) {
43222       {
43223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43224       };
43225     } catch (...) {
43226       {
43227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43228       };
43229     }
43230   }
43231
43232   jresult = (int)result;
43233   return jresult;
43234 }
43235
43236
43237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43238   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43239
43240   arg1 = (Dali::AlphaFunction *)jarg1;
43241   {
43242     try {
43243       delete arg1;
43244     } catch (std::out_of_range& e) {
43245       {
43246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43247       };
43248     } catch (std::exception& e) {
43249       {
43250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43251       };
43252     } catch (Dali::DaliException e) {
43253       {
43254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43255       };
43256     } catch (...) {
43257       {
43258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43259       };
43260     }
43261   }
43262
43263 }
43264
43265
43266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43267   void * jresult ;
43268   Dali::KeyFrames result;
43269
43270   {
43271     try {
43272       result = Dali::KeyFrames::New();
43273     } catch (std::out_of_range& e) {
43274       {
43275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43276       };
43277     } catch (std::exception& e) {
43278       {
43279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43280       };
43281     } catch (Dali::DaliException e) {
43282       {
43283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43284       };
43285     } catch (...) {
43286       {
43287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43288       };
43289     }
43290   }
43291
43292   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43293   return jresult;
43294 }
43295
43296
43297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43298   void * jresult ;
43299   Dali::BaseHandle arg1 ;
43300   Dali::BaseHandle *argp1 ;
43301   Dali::KeyFrames result;
43302
43303   argp1 = (Dali::BaseHandle *)jarg1;
43304   if (!argp1) {
43305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43306     return 0;
43307   }
43308   arg1 = *argp1;
43309   {
43310     try {
43311       result = Dali::KeyFrames::DownCast(arg1);
43312     } catch (std::out_of_range& e) {
43313       {
43314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43315       };
43316     } catch (std::exception& e) {
43317       {
43318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43319       };
43320     } catch (Dali::DaliException e) {
43321       {
43322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43323       };
43324     } catch (...) {
43325       {
43326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43327       };
43328     }
43329   }
43330
43331   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43332   return jresult;
43333 }
43334
43335
43336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43337   void * jresult ;
43338   Dali::KeyFrames *result = 0 ;
43339
43340   {
43341     try {
43342       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43343     } catch (std::out_of_range& e) {
43344       {
43345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43346       };
43347     } catch (std::exception& e) {
43348       {
43349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43350       };
43351     } catch (Dali::DaliException e) {
43352       {
43353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43354       };
43355     } catch (...) {
43356       {
43357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43358       };
43359     }
43360   }
43361
43362   jresult = (void *)result;
43363   return jresult;
43364 }
43365
43366
43367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43368   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43369
43370   arg1 = (Dali::KeyFrames *)jarg1;
43371   {
43372     try {
43373       delete arg1;
43374     } catch (std::out_of_range& e) {
43375       {
43376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43377       };
43378     } catch (std::exception& e) {
43379       {
43380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43381       };
43382     } catch (Dali::DaliException e) {
43383       {
43384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43385       };
43386     } catch (...) {
43387       {
43388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43389       };
43390     }
43391   }
43392
43393 }
43394
43395
43396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43397   void * jresult ;
43398   Dali::KeyFrames *arg1 = 0 ;
43399   Dali::KeyFrames *result = 0 ;
43400
43401   arg1 = (Dali::KeyFrames *)jarg1;
43402   if (!arg1) {
43403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43404     return 0;
43405   }
43406   {
43407     try {
43408       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43409     } catch (std::out_of_range& e) {
43410       {
43411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43412       };
43413     } catch (std::exception& e) {
43414       {
43415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43416       };
43417     } catch (Dali::DaliException e) {
43418       {
43419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43420       };
43421     } catch (...) {
43422       {
43423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43424       };
43425     }
43426   }
43427
43428   jresult = (void *)result;
43429   return jresult;
43430 }
43431
43432
43433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43434   void * jresult ;
43435   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43436   Dali::KeyFrames *arg2 = 0 ;
43437   Dali::KeyFrames *result = 0 ;
43438
43439   arg1 = (Dali::KeyFrames *)jarg1;
43440   arg2 = (Dali::KeyFrames *)jarg2;
43441   if (!arg2) {
43442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43443     return 0;
43444   }
43445   {
43446     try {
43447       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43448     } catch (std::out_of_range& e) {
43449       {
43450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43451       };
43452     } catch (std::exception& e) {
43453       {
43454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43455       };
43456     } catch (Dali::DaliException e) {
43457       {
43458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43459       };
43460     } catch (...) {
43461       {
43462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43463       };
43464     }
43465   }
43466
43467   jresult = (void *)result;
43468   return jresult;
43469 }
43470
43471
43472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43473   int jresult ;
43474   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43475   Dali::Property::Type result;
43476
43477   arg1 = (Dali::KeyFrames *)jarg1;
43478   {
43479     try {
43480       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43481     } catch (std::out_of_range& e) {
43482       {
43483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43484       };
43485     } catch (std::exception& e) {
43486       {
43487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43488       };
43489     } catch (Dali::DaliException e) {
43490       {
43491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43492       };
43493     } catch (...) {
43494       {
43495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43496       };
43497     }
43498   }
43499
43500   jresult = (int)result;
43501   return jresult;
43502 }
43503
43504
43505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43506   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43507   float arg2 ;
43508   Dali::Property::Value arg3 ;
43509   Dali::Property::Value *argp3 ;
43510
43511   arg1 = (Dali::KeyFrames *)jarg1;
43512   arg2 = (float)jarg2;
43513   argp3 = (Dali::Property::Value *)jarg3;
43514   if (!argp3) {
43515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43516     return ;
43517   }
43518   arg3 = *argp3;
43519   {
43520     try {
43521       (arg1)->Add(arg2,arg3);
43522     } catch (std::out_of_range& e) {
43523       {
43524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43525       };
43526     } catch (std::exception& e) {
43527       {
43528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43529       };
43530     } catch (Dali::DaliException e) {
43531       {
43532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43533       };
43534     } catch (...) {
43535       {
43536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43537       };
43538     }
43539   }
43540
43541 }
43542
43543
43544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43545   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43546   float arg2 ;
43547   Dali::Property::Value arg3 ;
43548   Dali::AlphaFunction arg4 ;
43549   Dali::Property::Value *argp3 ;
43550   Dali::AlphaFunction *argp4 ;
43551
43552   arg1 = (Dali::KeyFrames *)jarg1;
43553   arg2 = (float)jarg2;
43554   argp3 = (Dali::Property::Value *)jarg3;
43555   if (!argp3) {
43556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43557     return ;
43558   }
43559   arg3 = *argp3;
43560   argp4 = (Dali::AlphaFunction *)jarg4;
43561   if (!argp4) {
43562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43563     return ;
43564   }
43565   arg4 = *argp4;
43566   {
43567     try {
43568       (arg1)->Add(arg2,arg3,arg4);
43569     } catch (std::out_of_range& e) {
43570       {
43571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43572       };
43573     } catch (std::exception& e) {
43574       {
43575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43576       };
43577     } catch (Dali::DaliException e) {
43578       {
43579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43580       };
43581     } catch (...) {
43582       {
43583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43584       };
43585     }
43586   }
43587
43588 }
43589
43590
43591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43592   int jresult ;
43593   int result;
43594
43595   result = (int)Dali::Path::Property::POINTS;
43596   jresult = (int)result;
43597   return jresult;
43598 }
43599
43600
43601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43602   int jresult ;
43603   int result;
43604
43605   result = (int)Dali::Path::Property::CONTROL_POINTS;
43606   jresult = (int)result;
43607   return jresult;
43608 }
43609
43610
43611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43612   void * jresult ;
43613   Dali::Path::Property *result = 0 ;
43614
43615   {
43616     try {
43617       result = (Dali::Path::Property *)new Dali::Path::Property();
43618     } catch (std::out_of_range& e) {
43619       {
43620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43621       };
43622     } catch (std::exception& e) {
43623       {
43624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43625       };
43626     } catch (Dali::DaliException e) {
43627       {
43628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43629       };
43630     } catch (...) {
43631       {
43632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43633       };
43634     }
43635   }
43636
43637   jresult = (void *)result;
43638   return jresult;
43639 }
43640
43641
43642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43643   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43644
43645   arg1 = (Dali::Path::Property *)jarg1;
43646   {
43647     try {
43648       delete arg1;
43649     } catch (std::out_of_range& e) {
43650       {
43651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43652       };
43653     } catch (std::exception& e) {
43654       {
43655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43656       };
43657     } catch (Dali::DaliException e) {
43658       {
43659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43660       };
43661     } catch (...) {
43662       {
43663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43664       };
43665     }
43666   }
43667
43668 }
43669
43670
43671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43672   void * jresult ;
43673   Dali::Path result;
43674
43675   {
43676     try {
43677       result = Dali::Path::New();
43678     } catch (std::out_of_range& e) {
43679       {
43680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43681       };
43682     } catch (std::exception& e) {
43683       {
43684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43685       };
43686     } catch (Dali::DaliException e) {
43687       {
43688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43689       };
43690     } catch (...) {
43691       {
43692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43693       };
43694     }
43695   }
43696
43697   jresult = new Dali::Path((const Dali::Path &)result);
43698   return jresult;
43699 }
43700
43701
43702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43703   void * jresult ;
43704   Dali::BaseHandle arg1 ;
43705   Dali::BaseHandle *argp1 ;
43706   Dali::Path result;
43707
43708   argp1 = (Dali::BaseHandle *)jarg1;
43709   if (!argp1) {
43710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43711     return 0;
43712   }
43713   arg1 = *argp1;
43714   {
43715     try {
43716       result = Dali::Path::DownCast(arg1);
43717     } catch (std::out_of_range& e) {
43718       {
43719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43720       };
43721     } catch (std::exception& e) {
43722       {
43723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43724       };
43725     } catch (Dali::DaliException e) {
43726       {
43727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43728       };
43729     } catch (...) {
43730       {
43731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43732       };
43733     }
43734   }
43735
43736   jresult = new Dali::Path((const Dali::Path &)result);
43737   return jresult;
43738 }
43739
43740
43741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43742   void * jresult ;
43743   Dali::Path *result = 0 ;
43744
43745   {
43746     try {
43747       result = (Dali::Path *)new Dali::Path();
43748     } catch (std::out_of_range& e) {
43749       {
43750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43751       };
43752     } catch (std::exception& e) {
43753       {
43754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43755       };
43756     } catch (Dali::DaliException e) {
43757       {
43758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43759       };
43760     } catch (...) {
43761       {
43762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43763       };
43764     }
43765   }
43766
43767   jresult = (void *)result;
43768   return jresult;
43769 }
43770
43771
43772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43773   Dali::Path *arg1 = (Dali::Path *) 0 ;
43774
43775   arg1 = (Dali::Path *)jarg1;
43776   {
43777     try {
43778       delete arg1;
43779     } catch (std::out_of_range& e) {
43780       {
43781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43782       };
43783     } catch (std::exception& e) {
43784       {
43785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43786       };
43787     } catch (Dali::DaliException e) {
43788       {
43789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43790       };
43791     } catch (...) {
43792       {
43793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43794       };
43795     }
43796   }
43797
43798 }
43799
43800
43801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43802   void * jresult ;
43803   Dali::Path *arg1 = 0 ;
43804   Dali::Path *result = 0 ;
43805
43806   arg1 = (Dali::Path *)jarg1;
43807   if (!arg1) {
43808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43809     return 0;
43810   }
43811   {
43812     try {
43813       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43814     } catch (std::out_of_range& e) {
43815       {
43816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43817       };
43818     } catch (std::exception& e) {
43819       {
43820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43821       };
43822     } catch (Dali::DaliException e) {
43823       {
43824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43825       };
43826     } catch (...) {
43827       {
43828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43829       };
43830     }
43831   }
43832
43833   jresult = (void *)result;
43834   return jresult;
43835 }
43836
43837
43838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43839   void * jresult ;
43840   Dali::Path *arg1 = (Dali::Path *) 0 ;
43841   Dali::Path *arg2 = 0 ;
43842   Dali::Path *result = 0 ;
43843
43844   arg1 = (Dali::Path *)jarg1;
43845   arg2 = (Dali::Path *)jarg2;
43846   if (!arg2) {
43847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43848     return 0;
43849   }
43850   {
43851     try {
43852       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43853     } catch (std::out_of_range& e) {
43854       {
43855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43856       };
43857     } catch (std::exception& e) {
43858       {
43859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43860       };
43861     } catch (Dali::DaliException e) {
43862       {
43863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43864       };
43865     } catch (...) {
43866       {
43867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43868       };
43869     }
43870   }
43871
43872   jresult = (void *)result;
43873   return jresult;
43874 }
43875
43876
43877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43878   Dali::Path *arg1 = (Dali::Path *) 0 ;
43879   Dali::Vector3 *arg2 = 0 ;
43880
43881   arg1 = (Dali::Path *)jarg1;
43882   arg2 = (Dali::Vector3 *)jarg2;
43883   if (!arg2) {
43884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43885     return ;
43886   }
43887   {
43888     try {
43889       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43890     } catch (std::out_of_range& e) {
43891       {
43892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43893       };
43894     } catch (std::exception& e) {
43895       {
43896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43897       };
43898     } catch (Dali::DaliException e) {
43899       {
43900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43901       };
43902     } catch (...) {
43903       {
43904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43905       };
43906     }
43907   }
43908
43909 }
43910
43911
43912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43913   Dali::Path *arg1 = (Dali::Path *) 0 ;
43914   Dali::Vector3 *arg2 = 0 ;
43915
43916   arg1 = (Dali::Path *)jarg1;
43917   arg2 = (Dali::Vector3 *)jarg2;
43918   if (!arg2) {
43919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43920     return ;
43921   }
43922   {
43923     try {
43924       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43925     } catch (std::out_of_range& e) {
43926       {
43927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43928       };
43929     } catch (std::exception& e) {
43930       {
43931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43932       };
43933     } catch (Dali::DaliException e) {
43934       {
43935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43936       };
43937     } catch (...) {
43938       {
43939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43940       };
43941     }
43942   }
43943
43944 }
43945
43946
43947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43948   Dali::Path *arg1 = (Dali::Path *) 0 ;
43949   float arg2 ;
43950
43951   arg1 = (Dali::Path *)jarg1;
43952   arg2 = (float)jarg2;
43953   {
43954     try {
43955       (arg1)->GenerateControlPoints(arg2);
43956     } catch (std::out_of_range& e) {
43957       {
43958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43959       };
43960     } catch (std::exception& e) {
43961       {
43962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43963       };
43964     } catch (Dali::DaliException e) {
43965       {
43966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43967       };
43968     } catch (...) {
43969       {
43970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43971       };
43972     }
43973   }
43974
43975 }
43976
43977
43978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43979   Dali::Path *arg1 = (Dali::Path *) 0 ;
43980   float arg2 ;
43981   Dali::Vector3 *arg3 = 0 ;
43982   Dali::Vector3 *arg4 = 0 ;
43983
43984   arg1 = (Dali::Path *)jarg1;
43985   arg2 = (float)jarg2;
43986   arg3 = (Dali::Vector3 *)jarg3;
43987   if (!arg3) {
43988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43989     return ;
43990   }
43991   arg4 = (Dali::Vector3 *)jarg4;
43992   if (!arg4) {
43993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43994     return ;
43995   }
43996   {
43997     try {
43998       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43999     } catch (std::out_of_range& e) {
44000       {
44001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44002       };
44003     } catch (std::exception& e) {
44004       {
44005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44006       };
44007     } catch (Dali::DaliException e) {
44008       {
44009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44010       };
44011     } catch (...) {
44012       {
44013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44014       };
44015     }
44016   }
44017
44018 }
44019
44020
44021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
44022   void * jresult ;
44023   Dali::Path *arg1 = (Dali::Path *) 0 ;
44024   size_t arg2 ;
44025   Dali::Vector3 *result = 0 ;
44026
44027   arg1 = (Dali::Path *)jarg1;
44028   arg2 = (size_t)jarg2;
44029   {
44030     try {
44031       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
44032     } catch (std::out_of_range& e) {
44033       {
44034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44035       };
44036     } catch (std::exception& e) {
44037       {
44038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44039       };
44040     } catch (Dali::DaliException e) {
44041       {
44042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44043       };
44044     } catch (...) {
44045       {
44046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44047       };
44048     }
44049   }
44050
44051   jresult = (void *)result;
44052   return jresult;
44053 }
44054
44055
44056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
44057   void * jresult ;
44058   Dali::Path *arg1 = (Dali::Path *) 0 ;
44059   size_t arg2 ;
44060   Dali::Vector3 *result = 0 ;
44061
44062   arg1 = (Dali::Path *)jarg1;
44063   arg2 = (size_t)jarg2;
44064   {
44065     try {
44066       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
44067     } catch (std::out_of_range& e) {
44068       {
44069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44070       };
44071     } catch (std::exception& e) {
44072       {
44073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44074       };
44075     } catch (Dali::DaliException e) {
44076       {
44077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44078       };
44079     } catch (...) {
44080       {
44081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44082       };
44083     }
44084   }
44085
44086   jresult = (void *)result;
44087   return jresult;
44088 }
44089
44090
44091 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44092   unsigned long jresult ;
44093   Dali::Path *arg1 = (Dali::Path *) 0 ;
44094   size_t result;
44095
44096   arg1 = (Dali::Path *)jarg1;
44097   {
44098     try {
44099       result = ((Dali::Path const *)arg1)->GetPointCount();
44100     } catch (std::out_of_range& e) {
44101       {
44102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44103       };
44104     } catch (std::exception& e) {
44105       {
44106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44107       };
44108     } catch (Dali::DaliException e) {
44109       {
44110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44111       };
44112     } catch (...) {
44113       {
44114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44115       };
44116     }
44117   }
44118
44119   jresult = (unsigned long)result;
44120   return jresult;
44121 }
44122
44123
44124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44125   void * jresult ;
44126   float arg1 ;
44127   Dali::TimePeriod *result = 0 ;
44128
44129   arg1 = (float)jarg1;
44130   {
44131     try {
44132       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44133     } catch (std::out_of_range& e) {
44134       {
44135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44136       };
44137     } catch (std::exception& e) {
44138       {
44139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44140       };
44141     } catch (Dali::DaliException e) {
44142       {
44143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44144       };
44145     } catch (...) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44148       };
44149     }
44150   }
44151
44152   jresult = (void *)result;
44153   return jresult;
44154 }
44155
44156
44157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44158   void * jresult ;
44159   float arg1 ;
44160   float arg2 ;
44161   Dali::TimePeriod *result = 0 ;
44162
44163   arg1 = (float)jarg1;
44164   arg2 = (float)jarg2;
44165   {
44166     try {
44167       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44168     } catch (std::out_of_range& e) {
44169       {
44170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44171       };
44172     } catch (std::exception& e) {
44173       {
44174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44175       };
44176     } catch (Dali::DaliException e) {
44177       {
44178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44179       };
44180     } catch (...) {
44181       {
44182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44183       };
44184     }
44185   }
44186
44187   jresult = (void *)result;
44188   return jresult;
44189 }
44190
44191
44192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44193   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44194
44195   arg1 = (Dali::TimePeriod *)jarg1;
44196   {
44197     try {
44198       delete arg1;
44199     } catch (std::out_of_range& e) {
44200       {
44201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44202       };
44203     } catch (std::exception& e) {
44204       {
44205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44206       };
44207     } catch (Dali::DaliException e) {
44208       {
44209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44210       };
44211     } catch (...) {
44212       {
44213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44214       };
44215     }
44216   }
44217
44218 }
44219
44220
44221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44222   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44223   float arg2 ;
44224
44225   arg1 = (Dali::TimePeriod *)jarg1;
44226   arg2 = (float)jarg2;
44227   if (arg1) (arg1)->delaySeconds = arg2;
44228 }
44229
44230
44231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44232   float jresult ;
44233   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44234   float result;
44235
44236   arg1 = (Dali::TimePeriod *)jarg1;
44237   result = (float) ((arg1)->delaySeconds);
44238   jresult = result;
44239   return jresult;
44240 }
44241
44242
44243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44244   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44245   float arg2 ;
44246
44247   arg1 = (Dali::TimePeriod *)jarg1;
44248   arg2 = (float)jarg2;
44249   if (arg1) (arg1)->durationSeconds = arg2;
44250 }
44251
44252
44253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44254   float jresult ;
44255   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44256   float result;
44257
44258   arg1 = (Dali::TimePeriod *)jarg1;
44259   result = (float) ((arg1)->durationSeconds);
44260   jresult = result;
44261   return jresult;
44262 }
44263
44264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44265   int jresult ;
44266   int result;
44267
44268   result = (int)Dali::LinearConstrainer::Property::VALUE;
44269   jresult = (int)result;
44270   return jresult;
44271 }
44272
44273
44274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44275   int jresult ;
44276   int result;
44277
44278   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44279   jresult = (int)result;
44280   return jresult;
44281 }
44282
44283
44284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44285   void * jresult ;
44286   Dali::LinearConstrainer::Property *result = 0 ;
44287
44288   {
44289     try {
44290       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44291     } catch (std::out_of_range& e) {
44292       {
44293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44294       };
44295     } catch (std::exception& e) {
44296       {
44297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44298       };
44299     } catch (Dali::DaliException e) {
44300       {
44301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44302       };
44303     } catch (...) {
44304       {
44305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44306       };
44307     }
44308   }
44309
44310   jresult = (void *)result;
44311   return jresult;
44312 }
44313
44314
44315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44316   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44317
44318   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44319   {
44320     try {
44321       delete arg1;
44322     } catch (std::out_of_range& e) {
44323       {
44324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44325       };
44326     } catch (std::exception& e) {
44327       {
44328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44329       };
44330     } catch (Dali::DaliException e) {
44331       {
44332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44333       };
44334     } catch (...) {
44335       {
44336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44337       };
44338     }
44339   }
44340
44341 }
44342
44343
44344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44345   void * jresult ;
44346   Dali::LinearConstrainer result;
44347
44348   {
44349     try {
44350       result = Dali::LinearConstrainer::New();
44351     } catch (std::out_of_range& e) {
44352       {
44353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44354       };
44355     } catch (std::exception& e) {
44356       {
44357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44358       };
44359     } catch (Dali::DaliException e) {
44360       {
44361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44362       };
44363     } catch (...) {
44364       {
44365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44366       };
44367     }
44368   }
44369
44370   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44371   return jresult;
44372 }
44373
44374
44375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44376   void * jresult ;
44377   Dali::BaseHandle arg1 ;
44378   Dali::BaseHandle *argp1 ;
44379   Dali::LinearConstrainer result;
44380
44381   argp1 = (Dali::BaseHandle *)jarg1;
44382   if (!argp1) {
44383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44384     return 0;
44385   }
44386   arg1 = *argp1;
44387   {
44388     try {
44389       result = Dali::LinearConstrainer::DownCast(arg1);
44390     } catch (std::out_of_range& e) {
44391       {
44392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44393       };
44394     } catch (std::exception& e) {
44395       {
44396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44397       };
44398     } catch (Dali::DaliException e) {
44399       {
44400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44401       };
44402     } catch (...) {
44403       {
44404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44405       };
44406     }
44407   }
44408
44409   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44410   return jresult;
44411 }
44412
44413
44414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44415   void * jresult ;
44416   Dali::LinearConstrainer *result = 0 ;
44417
44418   {
44419     try {
44420       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44421     } catch (std::out_of_range& e) {
44422       {
44423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44424       };
44425     } catch (std::exception& e) {
44426       {
44427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44428       };
44429     } catch (Dali::DaliException e) {
44430       {
44431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44432       };
44433     } catch (...) {
44434       {
44435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44436       };
44437     }
44438   }
44439
44440   jresult = (void *)result;
44441   return jresult;
44442 }
44443
44444
44445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44446   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44447
44448   arg1 = (Dali::LinearConstrainer *)jarg1;
44449   {
44450     try {
44451       delete arg1;
44452     } catch (std::out_of_range& e) {
44453       {
44454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44455       };
44456     } catch (std::exception& e) {
44457       {
44458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44459       };
44460     } catch (Dali::DaliException e) {
44461       {
44462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44463       };
44464     } catch (...) {
44465       {
44466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44467       };
44468     }
44469   }
44470
44471 }
44472
44473
44474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44475   void * jresult ;
44476   Dali::LinearConstrainer *arg1 = 0 ;
44477   Dali::LinearConstrainer *result = 0 ;
44478
44479   arg1 = (Dali::LinearConstrainer *)jarg1;
44480   if (!arg1) {
44481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44482     return 0;
44483   }
44484   {
44485     try {
44486       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44487     } catch (std::out_of_range& e) {
44488       {
44489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44490       };
44491     } catch (std::exception& e) {
44492       {
44493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44494       };
44495     } catch (Dali::DaliException e) {
44496       {
44497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44498       };
44499     } catch (...) {
44500       {
44501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44502       };
44503     }
44504   }
44505
44506   jresult = (void *)result;
44507   return jresult;
44508 }
44509
44510
44511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44512   void * jresult ;
44513   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44514   Dali::LinearConstrainer *arg2 = 0 ;
44515   Dali::LinearConstrainer *result = 0 ;
44516
44517   arg1 = (Dali::LinearConstrainer *)jarg1;
44518   arg2 = (Dali::LinearConstrainer *)jarg2;
44519   if (!arg2) {
44520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44521     return 0;
44522   }
44523   {
44524     try {
44525       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44526     } catch (std::out_of_range& e) {
44527       {
44528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44529       };
44530     } catch (std::exception& e) {
44531       {
44532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44533       };
44534     } catch (Dali::DaliException e) {
44535       {
44536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44537       };
44538     } catch (...) {
44539       {
44540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44541       };
44542     }
44543   }
44544
44545   jresult = (void *)result;
44546   return jresult;
44547 }
44548
44549
44550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44551   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44552   SwigValueWrapper< Dali::Property > arg2 ;
44553   SwigValueWrapper< Dali::Property > arg3 ;
44554   Dali::Vector2 *arg4 = 0 ;
44555   Dali::Vector2 *arg5 = 0 ;
44556   Dali::Property *argp2 ;
44557   Dali::Property *argp3 ;
44558
44559   arg1 = (Dali::LinearConstrainer *)jarg1;
44560   argp2 = (Dali::Property *)jarg2;
44561   if (!argp2) {
44562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44563     return ;
44564   }
44565   arg2 = *argp2;
44566   argp3 = (Dali::Property *)jarg3;
44567   if (!argp3) {
44568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44569     return ;
44570   }
44571   arg3 = *argp3;
44572   arg4 = (Dali::Vector2 *)jarg4;
44573   if (!arg4) {
44574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44575     return ;
44576   }
44577   arg5 = (Dali::Vector2 *)jarg5;
44578   if (!arg5) {
44579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44580     return ;
44581   }
44582   {
44583     try {
44584       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44585     } catch (std::out_of_range& e) {
44586       {
44587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44588       };
44589     } catch (std::exception& e) {
44590       {
44591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44592       };
44593     } catch (Dali::DaliException e) {
44594       {
44595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44596       };
44597     } catch (...) {
44598       {
44599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44600       };
44601     }
44602   }
44603
44604 }
44605
44606
44607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44608   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44609   SwigValueWrapper< Dali::Property > arg2 ;
44610   SwigValueWrapper< Dali::Property > arg3 ;
44611   Dali::Vector2 *arg4 = 0 ;
44612   Dali::Property *argp2 ;
44613   Dali::Property *argp3 ;
44614
44615   arg1 = (Dali::LinearConstrainer *)jarg1;
44616   argp2 = (Dali::Property *)jarg2;
44617   if (!argp2) {
44618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44619     return ;
44620   }
44621   arg2 = *argp2;
44622   argp3 = (Dali::Property *)jarg3;
44623   if (!argp3) {
44624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44625     return ;
44626   }
44627   arg3 = *argp3;
44628   arg4 = (Dali::Vector2 *)jarg4;
44629   if (!arg4) {
44630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44631     return ;
44632   }
44633   {
44634     try {
44635       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44636     } catch (std::out_of_range& e) {
44637       {
44638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44639       };
44640     } catch (std::exception& e) {
44641       {
44642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44643       };
44644     } catch (Dali::DaliException e) {
44645       {
44646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44647       };
44648     } catch (...) {
44649       {
44650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44651       };
44652     }
44653   }
44654
44655 }
44656
44657
44658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44659   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44660   Dali::Handle *arg2 = 0 ;
44661
44662   arg1 = (Dali::LinearConstrainer *)jarg1;
44663   arg2 = (Dali::Handle *)jarg2;
44664   if (!arg2) {
44665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44666     return ;
44667   }
44668   {
44669     try {
44670       (arg1)->Remove(*arg2);
44671     } catch (std::out_of_range& e) {
44672       {
44673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44674       };
44675     } catch (std::exception& e) {
44676       {
44677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44678       };
44679     } catch (Dali::DaliException e) {
44680       {
44681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44682       };
44683     } catch (...) {
44684       {
44685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44686       };
44687     }
44688   }
44689
44690 }
44691
44692
44693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44694   int jresult ;
44695   int result;
44696
44697   result = (int)Dali::PathConstrainer::Property::FORWARD;
44698   jresult = (int)result;
44699   return jresult;
44700 }
44701
44702
44703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44704   int jresult ;
44705   int result;
44706
44707   result = (int)Dali::PathConstrainer::Property::POINTS;
44708   jresult = (int)result;
44709   return jresult;
44710 }
44711
44712
44713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44714   int jresult ;
44715   int result;
44716
44717   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44718   jresult = (int)result;
44719   return jresult;
44720 }
44721
44722
44723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44724   void * jresult ;
44725   Dali::PathConstrainer::Property *result = 0 ;
44726
44727   {
44728     try {
44729       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44730     } catch (std::out_of_range& e) {
44731       {
44732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44733       };
44734     } catch (std::exception& e) {
44735       {
44736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44737       };
44738     } catch (Dali::DaliException e) {
44739       {
44740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44741       };
44742     } catch (...) {
44743       {
44744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44745       };
44746     }
44747   }
44748
44749   jresult = (void *)result;
44750   return jresult;
44751 }
44752
44753
44754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44755   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44756
44757   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44758   {
44759     try {
44760       delete arg1;
44761     } catch (std::out_of_range& e) {
44762       {
44763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44764       };
44765     } catch (std::exception& e) {
44766       {
44767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44768       };
44769     } catch (Dali::DaliException e) {
44770       {
44771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44772       };
44773     } catch (...) {
44774       {
44775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44776       };
44777     }
44778   }
44779
44780 }
44781
44782
44783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44784   void * jresult ;
44785   Dali::PathConstrainer result;
44786
44787   {
44788     try {
44789       result = Dali::PathConstrainer::New();
44790     } catch (std::out_of_range& e) {
44791       {
44792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44793       };
44794     } catch (std::exception& e) {
44795       {
44796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44797       };
44798     } catch (Dali::DaliException e) {
44799       {
44800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44801       };
44802     } catch (...) {
44803       {
44804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44805       };
44806     }
44807   }
44808
44809   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44810   return jresult;
44811 }
44812
44813
44814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44815   void * jresult ;
44816   Dali::BaseHandle arg1 ;
44817   Dali::BaseHandle *argp1 ;
44818   Dali::PathConstrainer result;
44819
44820   argp1 = (Dali::BaseHandle *)jarg1;
44821   if (!argp1) {
44822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44823     return 0;
44824   }
44825   arg1 = *argp1;
44826   {
44827     try {
44828       result = Dali::PathConstrainer::DownCast(arg1);
44829     } catch (std::out_of_range& e) {
44830       {
44831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44832       };
44833     } catch (std::exception& e) {
44834       {
44835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44836       };
44837     } catch (Dali::DaliException e) {
44838       {
44839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44840       };
44841     } catch (...) {
44842       {
44843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44844       };
44845     }
44846   }
44847
44848   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44849   return jresult;
44850 }
44851
44852
44853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44854   void * jresult ;
44855   Dali::PathConstrainer *result = 0 ;
44856
44857   {
44858     try {
44859       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44860     } catch (std::out_of_range& e) {
44861       {
44862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44863       };
44864     } catch (std::exception& e) {
44865       {
44866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44867       };
44868     } catch (Dali::DaliException e) {
44869       {
44870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44871       };
44872     } catch (...) {
44873       {
44874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44875       };
44876     }
44877   }
44878
44879   jresult = (void *)result;
44880   return jresult;
44881 }
44882
44883
44884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44885   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44886
44887   arg1 = (Dali::PathConstrainer *)jarg1;
44888   {
44889     try {
44890       delete arg1;
44891     } catch (std::out_of_range& e) {
44892       {
44893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44894       };
44895     } catch (std::exception& e) {
44896       {
44897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44898       };
44899     } catch (Dali::DaliException e) {
44900       {
44901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44902       };
44903     } catch (...) {
44904       {
44905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44906       };
44907     }
44908   }
44909
44910 }
44911
44912
44913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44914   void * jresult ;
44915   Dali::PathConstrainer *arg1 = 0 ;
44916   Dali::PathConstrainer *result = 0 ;
44917
44918   arg1 = (Dali::PathConstrainer *)jarg1;
44919   if (!arg1) {
44920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44921     return 0;
44922   }
44923   {
44924     try {
44925       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44926     } catch (std::out_of_range& e) {
44927       {
44928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44929       };
44930     } catch (std::exception& e) {
44931       {
44932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44933       };
44934     } catch (Dali::DaliException e) {
44935       {
44936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44937       };
44938     } catch (...) {
44939       {
44940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44941       };
44942     }
44943   }
44944
44945   jresult = (void *)result;
44946   return jresult;
44947 }
44948
44949
44950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44951   void * jresult ;
44952   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44953   Dali::PathConstrainer *arg2 = 0 ;
44954   Dali::PathConstrainer *result = 0 ;
44955
44956   arg1 = (Dali::PathConstrainer *)jarg1;
44957   arg2 = (Dali::PathConstrainer *)jarg2;
44958   if (!arg2) {
44959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44960     return 0;
44961   }
44962   {
44963     try {
44964       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44965     } catch (std::out_of_range& e) {
44966       {
44967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44968       };
44969     } catch (std::exception& e) {
44970       {
44971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44972       };
44973     } catch (Dali::DaliException e) {
44974       {
44975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44976       };
44977     } catch (...) {
44978       {
44979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44980       };
44981     }
44982   }
44983
44984   jresult = (void *)result;
44985   return jresult;
44986 }
44987
44988
44989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44990   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44991   SwigValueWrapper< Dali::Property > arg2 ;
44992   SwigValueWrapper< Dali::Property > arg3 ;
44993   Dali::Vector2 *arg4 = 0 ;
44994   Dali::Vector2 *arg5 = 0 ;
44995   Dali::Property *argp2 ;
44996   Dali::Property *argp3 ;
44997
44998   arg1 = (Dali::PathConstrainer *)jarg1;
44999   argp2 = (Dali::Property *)jarg2;
45000   if (!argp2) {
45001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45002     return ;
45003   }
45004   arg2 = *argp2;
45005   argp3 = (Dali::Property *)jarg3;
45006   if (!argp3) {
45007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45008     return ;
45009   }
45010   arg3 = *argp3;
45011   arg4 = (Dali::Vector2 *)jarg4;
45012   if (!arg4) {
45013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45014     return ;
45015   }
45016   arg5 = (Dali::Vector2 *)jarg5;
45017   if (!arg5) {
45018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45019     return ;
45020   }
45021   {
45022     try {
45023       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
45024     } catch (std::out_of_range& e) {
45025       {
45026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45027       };
45028     } catch (std::exception& e) {
45029       {
45030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45031       };
45032     } catch (Dali::DaliException e) {
45033       {
45034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45035       };
45036     } catch (...) {
45037       {
45038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45039       };
45040     }
45041   }
45042
45043 }
45044
45045
45046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45047   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45048   SwigValueWrapper< Dali::Property > arg2 ;
45049   SwigValueWrapper< Dali::Property > arg3 ;
45050   Dali::Vector2 *arg4 = 0 ;
45051   Dali::Property *argp2 ;
45052   Dali::Property *argp3 ;
45053
45054   arg1 = (Dali::PathConstrainer *)jarg1;
45055   argp2 = (Dali::Property *)jarg2;
45056   if (!argp2) {
45057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45058     return ;
45059   }
45060   arg2 = *argp2;
45061   argp3 = (Dali::Property *)jarg3;
45062   if (!argp3) {
45063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45064     return ;
45065   }
45066   arg3 = *argp3;
45067   arg4 = (Dali::Vector2 *)jarg4;
45068   if (!arg4) {
45069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45070     return ;
45071   }
45072   {
45073     try {
45074       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
45075     } catch (std::out_of_range& e) {
45076       {
45077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45078       };
45079     } catch (std::exception& e) {
45080       {
45081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45082       };
45083     } catch (Dali::DaliException e) {
45084       {
45085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45086       };
45087     } catch (...) {
45088       {
45089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45090       };
45091     }
45092   }
45093
45094 }
45095
45096
45097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45098   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45099   Dali::Handle *arg2 = 0 ;
45100
45101   arg1 = (Dali::PathConstrainer *)jarg1;
45102   arg2 = (Dali::Handle *)jarg2;
45103   if (!arg2) {
45104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45105     return ;
45106   }
45107   {
45108     try {
45109       (arg1)->Remove(*arg2);
45110     } catch (std::out_of_range& e) {
45111       {
45112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45113       };
45114     } catch (std::exception& e) {
45115       {
45116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45117       };
45118     } catch (Dali::DaliException e) {
45119       {
45120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45121       };
45122     } catch (...) {
45123       {
45124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45125       };
45126     }
45127   }
45128
45129 }
45130
45131
45132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45133   int jresult ;
45134   Dali::FittingMode::Type result;
45135
45136   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45137   jresult = (int)result;
45138   return jresult;
45139 }
45140
45141
45142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45143   int jresult ;
45144   Dali::SamplingMode::Type result;
45145
45146   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45147   jresult = (int)result;
45148   return jresult;
45149 }
45150
45151
45152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45153   void * jresult ;
45154   Dali::BufferImage *result = 0 ;
45155
45156   {
45157     try {
45158       result = (Dali::BufferImage *)new Dali::BufferImage();
45159     } catch (std::out_of_range& e) {
45160       {
45161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45162       };
45163     } catch (std::exception& e) {
45164       {
45165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45166       };
45167     } catch (Dali::DaliException e) {
45168       {
45169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45170       };
45171     } catch (...) {
45172       {
45173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45174       };
45175     }
45176   }
45177
45178   jresult = (void *)result;
45179   return jresult;
45180 }
45181
45182
45183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45184   void * jresult ;
45185   unsigned int arg1 ;
45186   unsigned int arg2 ;
45187   Dali::Pixel::Format arg3 ;
45188   Dali::BufferImage result;
45189
45190   arg1 = (unsigned int)jarg1;
45191   arg2 = (unsigned int)jarg2;
45192   arg3 = (Dali::Pixel::Format)jarg3;
45193   {
45194     try {
45195       result = Dali::BufferImage::New(arg1,arg2,arg3);
45196     } catch (std::out_of_range& e) {
45197       {
45198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45199       };
45200     } catch (std::exception& e) {
45201       {
45202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45203       };
45204     } catch (Dali::DaliException e) {
45205       {
45206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45207       };
45208     } catch (...) {
45209       {
45210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45211       };
45212     }
45213   }
45214
45215   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45216   return jresult;
45217 }
45218
45219
45220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45221   void * jresult ;
45222   unsigned int arg1 ;
45223   unsigned int arg2 ;
45224   Dali::BufferImage result;
45225
45226   arg1 = (unsigned int)jarg1;
45227   arg2 = (unsigned int)jarg2;
45228   {
45229     try {
45230       result = Dali::BufferImage::New(arg1,arg2);
45231     } catch (std::out_of_range& e) {
45232       {
45233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45234       };
45235     } catch (std::exception& e) {
45236       {
45237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45238       };
45239     } catch (Dali::DaliException e) {
45240       {
45241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45242       };
45243     } catch (...) {
45244       {
45245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45246       };
45247     }
45248   }
45249
45250   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45251   return jresult;
45252 }
45253
45254
45255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45256   void * jresult ;
45257   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45258   unsigned int arg2 ;
45259   unsigned int arg3 ;
45260   Dali::Pixel::Format arg4 ;
45261   unsigned int arg5 ;
45262   Dali::BufferImage result;
45263
45264   arg1 = jarg1;
45265   arg2 = (unsigned int)jarg2;
45266   arg3 = (unsigned int)jarg3;
45267   arg4 = (Dali::Pixel::Format)jarg4;
45268   arg5 = (unsigned int)jarg5;
45269   {
45270     try {
45271       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45272     } catch (std::out_of_range& e) {
45273       {
45274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45275       };
45276     } catch (std::exception& e) {
45277       {
45278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45279       };
45280     } catch (Dali::DaliException e) {
45281       {
45282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45283       };
45284     } catch (...) {
45285       {
45286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45287       };
45288     }
45289   }
45290
45291   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45292
45293
45294   return jresult;
45295 }
45296
45297
45298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45299   void * jresult ;
45300   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45301   unsigned int arg2 ;
45302   unsigned int arg3 ;
45303   Dali::Pixel::Format arg4 ;
45304   Dali::BufferImage result;
45305
45306   arg1 = jarg1;
45307   arg2 = (unsigned int)jarg2;
45308   arg3 = (unsigned int)jarg3;
45309   arg4 = (Dali::Pixel::Format)jarg4;
45310   {
45311     try {
45312       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45313     } catch (std::out_of_range& e) {
45314       {
45315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45316       };
45317     } catch (std::exception& e) {
45318       {
45319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45320       };
45321     } catch (Dali::DaliException e) {
45322       {
45323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45324       };
45325     } catch (...) {
45326       {
45327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45328       };
45329     }
45330   }
45331
45332   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45333
45334
45335   return jresult;
45336 }
45337
45338
45339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45340   void * jresult ;
45341   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45342   unsigned int arg2 ;
45343   unsigned int arg3 ;
45344   Dali::BufferImage result;
45345
45346   arg1 = jarg1;
45347   arg2 = (unsigned int)jarg2;
45348   arg3 = (unsigned int)jarg3;
45349   {
45350     try {
45351       result = Dali::BufferImage::New(arg1,arg2,arg3);
45352     } catch (std::out_of_range& e) {
45353       {
45354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45355       };
45356     } catch (std::exception& e) {
45357       {
45358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45359       };
45360     } catch (Dali::DaliException e) {
45361       {
45362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45363       };
45364     } catch (...) {
45365       {
45366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45367       };
45368     }
45369   }
45370
45371   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45372
45373
45374   return jresult;
45375 }
45376
45377
45378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45379   void * jresult ;
45380   Dali::BaseHandle arg1 ;
45381   Dali::BaseHandle *argp1 ;
45382   Dali::BufferImage result;
45383
45384   argp1 = (Dali::BaseHandle *)jarg1;
45385   if (!argp1) {
45386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45387     return 0;
45388   }
45389   arg1 = *argp1;
45390   {
45391     try {
45392       result = Dali::BufferImage::DownCast(arg1);
45393     } catch (std::out_of_range& e) {
45394       {
45395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45396       };
45397     } catch (std::exception& e) {
45398       {
45399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45400       };
45401     } catch (Dali::DaliException e) {
45402       {
45403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45404       };
45405     } catch (...) {
45406       {
45407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45408       };
45409     }
45410   }
45411
45412   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45413   return jresult;
45414 }
45415
45416
45417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45418   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45419
45420   arg1 = (Dali::BufferImage *)jarg1;
45421   {
45422     try {
45423       delete arg1;
45424     } catch (std::out_of_range& e) {
45425       {
45426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45427       };
45428     } catch (std::exception& e) {
45429       {
45430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45431       };
45432     } catch (Dali::DaliException e) {
45433       {
45434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45435       };
45436     } catch (...) {
45437       {
45438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45439       };
45440     }
45441   }
45442
45443 }
45444
45445
45446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45447   void * jresult ;
45448   Dali::BufferImage *arg1 = 0 ;
45449   Dali::BufferImage *result = 0 ;
45450
45451   arg1 = (Dali::BufferImage *)jarg1;
45452   if (!arg1) {
45453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45454     return 0;
45455   }
45456   {
45457     try {
45458       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45459     } catch (std::out_of_range& e) {
45460       {
45461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45462       };
45463     } catch (std::exception& e) {
45464       {
45465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45466       };
45467     } catch (Dali::DaliException e) {
45468       {
45469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45470       };
45471     } catch (...) {
45472       {
45473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45474       };
45475     }
45476   }
45477
45478   jresult = (void *)result;
45479   return jresult;
45480 }
45481
45482
45483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45484   void * jresult ;
45485   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45486   Dali::BufferImage *arg2 = 0 ;
45487   Dali::BufferImage *result = 0 ;
45488
45489   arg1 = (Dali::BufferImage *)jarg1;
45490   arg2 = (Dali::BufferImage *)jarg2;
45491   if (!arg2) {
45492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45493     return 0;
45494   }
45495   {
45496     try {
45497       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45498     } catch (std::out_of_range& e) {
45499       {
45500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45501       };
45502     } catch (std::exception& e) {
45503       {
45504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45505       };
45506     } catch (Dali::DaliException e) {
45507       {
45508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45509       };
45510     } catch (...) {
45511       {
45512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45513       };
45514     }
45515   }
45516
45517   jresult = (void *)result;
45518   return jresult;
45519 }
45520
45521
45522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45523   void * jresult ;
45524   Dali::BufferImage result;
45525
45526   {
45527     try {
45528       result = Dali::BufferImage::WHITE();
45529     } catch (std::out_of_range& e) {
45530       {
45531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45532       };
45533     } catch (std::exception& e) {
45534       {
45535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45536       };
45537     } catch (Dali::DaliException e) {
45538       {
45539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45540       };
45541     } catch (...) {
45542       {
45543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45544       };
45545     }
45546   }
45547
45548   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45549   return jresult;
45550 }
45551
45552
45553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45554   void * jresult ;
45555   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45556   Dali::PixelBuffer *result = 0 ;
45557
45558   arg1 = (Dali::BufferImage *)jarg1;
45559   {
45560     try {
45561       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45562     } catch (std::out_of_range& e) {
45563       {
45564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45565       };
45566     } catch (std::exception& e) {
45567       {
45568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45569       };
45570     } catch (Dali::DaliException e) {
45571       {
45572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45573       };
45574     } catch (...) {
45575       {
45576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45577       };
45578     }
45579   }
45580
45581   jresult = (void *)result;
45582   return jresult;
45583 }
45584
45585
45586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45587   unsigned int jresult ;
45588   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45589   unsigned int result;
45590
45591   arg1 = (Dali::BufferImage *)jarg1;
45592   {
45593     try {
45594       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45595     } catch (std::out_of_range& e) {
45596       {
45597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45598       };
45599     } catch (std::exception& e) {
45600       {
45601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45602       };
45603     } catch (Dali::DaliException e) {
45604       {
45605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45606       };
45607     } catch (...) {
45608       {
45609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45610       };
45611     }
45612   }
45613
45614   jresult = result;
45615   return jresult;
45616 }
45617
45618
45619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45620   unsigned int jresult ;
45621   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45622   unsigned int result;
45623
45624   arg1 = (Dali::BufferImage *)jarg1;
45625   {
45626     try {
45627       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45628     } catch (std::out_of_range& e) {
45629       {
45630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45631       };
45632     } catch (std::exception& e) {
45633       {
45634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45635       };
45636     } catch (Dali::DaliException e) {
45637       {
45638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45639       };
45640     } catch (...) {
45641       {
45642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45643       };
45644     }
45645   }
45646
45647   jresult = result;
45648   return jresult;
45649 }
45650
45651
45652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45653   int jresult ;
45654   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45655   Dali::Pixel::Format result;
45656
45657   arg1 = (Dali::BufferImage *)jarg1;
45658   {
45659     try {
45660       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45661     } catch (std::out_of_range& e) {
45662       {
45663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45664       };
45665     } catch (std::exception& e) {
45666       {
45667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (Dali::DaliException e) {
45670       {
45671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45672       };
45673     } catch (...) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45676       };
45677     }
45678   }
45679
45680   jresult = (int)result;
45681   return jresult;
45682 }
45683
45684
45685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45686   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45687
45688   arg1 = (Dali::BufferImage *)jarg1;
45689   {
45690     try {
45691       (arg1)->Update();
45692     } catch (std::out_of_range& e) {
45693       {
45694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45695       };
45696     } catch (std::exception& e) {
45697       {
45698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45699       };
45700     } catch (Dali::DaliException e) {
45701       {
45702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45703       };
45704     } catch (...) {
45705       {
45706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45707       };
45708     }
45709   }
45710
45711 }
45712
45713
45714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45715   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45716   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45717   Dali::RectArea *argp2 ;
45718
45719   arg1 = (Dali::BufferImage *)jarg1;
45720   argp2 = (Dali::RectArea *)jarg2;
45721   if (!argp2) {
45722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45723     return ;
45724   }
45725   arg2 = *argp2;
45726   {
45727     try {
45728       (arg1)->Update(arg2);
45729     } catch (std::out_of_range& e) {
45730       {
45731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45732       };
45733     } catch (std::exception& e) {
45734       {
45735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45736       };
45737     } catch (Dali::DaliException e) {
45738       {
45739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45740       };
45741     } catch (...) {
45742       {
45743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45744       };
45745     }
45746   }
45747
45748 }
45749
45750
45751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45752   unsigned int jresult ;
45753   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45754   bool result;
45755
45756   arg1 = (Dali::BufferImage *)jarg1;
45757   {
45758     try {
45759       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45760     } catch (std::out_of_range& e) {
45761       {
45762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45763       };
45764     } catch (std::exception& e) {
45765       {
45766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45767       };
45768     } catch (Dali::DaliException e) {
45769       {
45770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45771       };
45772     } catch (...) {
45773       {
45774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45775       };
45776     }
45777   }
45778
45779   jresult = result;
45780   return jresult;
45781 }
45782
45783
45784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45785   void * jresult ;
45786   Dali::EncodedBufferImage *result = 0 ;
45787
45788   {
45789     try {
45790       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45791     } catch (std::out_of_range& e) {
45792       {
45793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45794       };
45795     } catch (std::exception& e) {
45796       {
45797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45798       };
45799     } catch (Dali::DaliException e) {
45800       {
45801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45802       };
45803     } catch (...) {
45804       {
45805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45806       };
45807     }
45808   }
45809
45810   jresult = (void *)result;
45811   return jresult;
45812 }
45813
45814
45815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45816   void * jresult ;
45817   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45818   std::size_t arg2 ;
45819   Dali::EncodedBufferImage result;
45820
45821   arg1 = (uint8_t *)jarg1;
45822   arg2 = (std::size_t)jarg2;
45823   {
45824     try {
45825       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45826     } catch (std::out_of_range& e) {
45827       {
45828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45829       };
45830     } catch (std::exception& e) {
45831       {
45832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45833       };
45834     } catch (Dali::DaliException e) {
45835       {
45836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45837       };
45838     } catch (...) {
45839       {
45840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45841       };
45842     }
45843   }
45844
45845   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45846   return jresult;
45847 }
45848
45849
45850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45851   void * jresult ;
45852   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45853   std::size_t arg2 ;
45854   Dali::ImageDimensions arg3 ;
45855   Dali::FittingMode::Type arg4 ;
45856   Dali::SamplingMode::Type arg5 ;
45857   bool arg6 ;
45858   Dali::ImageDimensions *argp3 ;
45859   Dali::EncodedBufferImage result;
45860
45861   arg1 = (uint8_t *)jarg1;
45862   arg2 = (std::size_t)jarg2;
45863   argp3 = (Dali::ImageDimensions *)jarg3;
45864   if (!argp3) {
45865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45866     return 0;
45867   }
45868   arg3 = *argp3;
45869   arg4 = (Dali::FittingMode::Type)jarg4;
45870   arg5 = (Dali::SamplingMode::Type)jarg5;
45871   arg6 = jarg6 ? true : false;
45872   {
45873     try {
45874       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45875     } catch (std::out_of_range& e) {
45876       {
45877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45878       };
45879     } catch (std::exception& e) {
45880       {
45881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45882       };
45883     } catch (Dali::DaliException e) {
45884       {
45885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45886       };
45887     } catch (...) {
45888       {
45889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45890       };
45891     }
45892   }
45893
45894   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45895   return jresult;
45896 }
45897
45898
45899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45900   void * jresult ;
45901   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45902   std::size_t arg2 ;
45903   Dali::ImageDimensions arg3 ;
45904   Dali::FittingMode::Type arg4 ;
45905   Dali::SamplingMode::Type arg5 ;
45906   Dali::ImageDimensions *argp3 ;
45907   Dali::EncodedBufferImage result;
45908
45909   arg1 = (uint8_t *)jarg1;
45910   arg2 = (std::size_t)jarg2;
45911   argp3 = (Dali::ImageDimensions *)jarg3;
45912   if (!argp3) {
45913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45914     return 0;
45915   }
45916   arg3 = *argp3;
45917   arg4 = (Dali::FittingMode::Type)jarg4;
45918   arg5 = (Dali::SamplingMode::Type)jarg5;
45919   {
45920     try {
45921       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45922     } catch (std::out_of_range& e) {
45923       {
45924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45925       };
45926     } catch (std::exception& e) {
45927       {
45928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45929       };
45930     } catch (Dali::DaliException e) {
45931       {
45932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45933       };
45934     } catch (...) {
45935       {
45936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45937       };
45938     }
45939   }
45940
45941   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45942   return jresult;
45943 }
45944
45945
45946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45947   void * jresult ;
45948   Dali::BaseHandle arg1 ;
45949   Dali::BaseHandle *argp1 ;
45950   Dali::EncodedBufferImage result;
45951
45952   argp1 = (Dali::BaseHandle *)jarg1;
45953   if (!argp1) {
45954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45955     return 0;
45956   }
45957   arg1 = *argp1;
45958   {
45959     try {
45960       result = Dali::EncodedBufferImage::DownCast(arg1);
45961     } catch (std::out_of_range& e) {
45962       {
45963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45964       };
45965     } catch (std::exception& e) {
45966       {
45967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45968       };
45969     } catch (Dali::DaliException e) {
45970       {
45971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45972       };
45973     } catch (...) {
45974       {
45975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45976       };
45977     }
45978   }
45979
45980   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45981   return jresult;
45982 }
45983
45984
45985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45986   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45987
45988   arg1 = (Dali::EncodedBufferImage *)jarg1;
45989   {
45990     try {
45991       delete arg1;
45992     } catch (std::out_of_range& e) {
45993       {
45994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45995       };
45996     } catch (std::exception& e) {
45997       {
45998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45999       };
46000     } catch (Dali::DaliException e) {
46001       {
46002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46003       };
46004     } catch (...) {
46005       {
46006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46007       };
46008     }
46009   }
46010
46011 }
46012
46013
46014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
46015   void * jresult ;
46016   Dali::EncodedBufferImage *arg1 = 0 ;
46017   Dali::EncodedBufferImage *result = 0 ;
46018
46019   arg1 = (Dali::EncodedBufferImage *)jarg1;
46020   if (!arg1) {
46021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
46022     return 0;
46023   }
46024   {
46025     try {
46026       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
46027     } catch (std::out_of_range& e) {
46028       {
46029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46030       };
46031     } catch (std::exception& e) {
46032       {
46033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46034       };
46035     } catch (Dali::DaliException e) {
46036       {
46037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46038       };
46039     } catch (...) {
46040       {
46041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46042       };
46043     }
46044   }
46045
46046   jresult = (void *)result;
46047   return jresult;
46048 }
46049
46050
46051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
46052   void * jresult ;
46053   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
46054   Dali::EncodedBufferImage *arg2 = 0 ;
46055   Dali::EncodedBufferImage *result = 0 ;
46056
46057   arg1 = (Dali::EncodedBufferImage *)jarg1;
46058   arg2 = (Dali::EncodedBufferImage *)jarg2;
46059   if (!arg2) {
46060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
46061     return 0;
46062   }
46063   {
46064     try {
46065       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
46066     } catch (std::out_of_range& e) {
46067       {
46068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46069       };
46070     } catch (std::exception& e) {
46071       {
46072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46073       };
46074     } catch (Dali::DaliException e) {
46075       {
46076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46077       };
46078     } catch (...) {
46079       {
46080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46081       };
46082     }
46083   }
46084
46085   jresult = (void *)result;
46086   return jresult;
46087 }
46088
46089
46090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
46091   void * jresult ;
46092   Dali::NativeImage *result = 0 ;
46093
46094   {
46095     try {
46096       result = (Dali::NativeImage *)new Dali::NativeImage();
46097     } catch (std::out_of_range& e) {
46098       {
46099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46100       };
46101     } catch (std::exception& e) {
46102       {
46103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46104       };
46105     } catch (Dali::DaliException e) {
46106       {
46107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46108       };
46109     } catch (...) {
46110       {
46111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46112       };
46113     }
46114   }
46115
46116   jresult = (void *)result;
46117   return jresult;
46118 }
46119
46120
46121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46122   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46123
46124   arg1 = (Dali::NativeImage *)jarg1;
46125   {
46126     try {
46127       delete arg1;
46128     } catch (std::out_of_range& e) {
46129       {
46130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46131       };
46132     } catch (std::exception& e) {
46133       {
46134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46135       };
46136     } catch (Dali::DaliException e) {
46137       {
46138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46139       };
46140     } catch (...) {
46141       {
46142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46143       };
46144     }
46145   }
46146
46147 }
46148
46149
46150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46151   void * jresult ;
46152   Dali::NativeImage *arg1 = 0 ;
46153   Dali::NativeImage *result = 0 ;
46154
46155   arg1 = (Dali::NativeImage *)jarg1;
46156   if (!arg1) {
46157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46158     return 0;
46159   }
46160   {
46161     try {
46162       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46163     } catch (std::out_of_range& e) {
46164       {
46165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46166       };
46167     } catch (std::exception& e) {
46168       {
46169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46170       };
46171     } catch (Dali::DaliException e) {
46172       {
46173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46174       };
46175     } catch (...) {
46176       {
46177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46178       };
46179     }
46180   }
46181
46182   jresult = (void *)result;
46183   return jresult;
46184 }
46185
46186
46187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46188   void * jresult ;
46189   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46190   Dali::NativeImage *arg2 = 0 ;
46191   Dali::NativeImage *result = 0 ;
46192
46193   arg1 = (Dali::NativeImage *)jarg1;
46194   arg2 = (Dali::NativeImage *)jarg2;
46195   if (!arg2) {
46196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46197     return 0;
46198   }
46199   {
46200     try {
46201       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46202     } catch (std::out_of_range& e) {
46203       {
46204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46205       };
46206     } catch (std::exception& e) {
46207       {
46208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46209       };
46210     } catch (Dali::DaliException e) {
46211       {
46212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46213       };
46214     } catch (...) {
46215       {
46216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46217       };
46218     }
46219   }
46220
46221   jresult = (void *)result;
46222   return jresult;
46223 }
46224
46225
46226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46227   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46228
46229   arg1 = (Dali::NativeImage *)jarg1;
46230   {
46231     try {
46232       (arg1)->CreateGlTexture();
46233     } catch (std::out_of_range& e) {
46234       {
46235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46236       };
46237     } catch (std::exception& e) {
46238       {
46239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46240       };
46241     } catch (Dali::DaliException e) {
46242       {
46243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46244       };
46245     } catch (...) {
46246       {
46247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46248       };
46249     }
46250   }
46251
46252 }
46253
46254
46255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46256   void * jresult ;
46257   NativeImageInterface *arg1 = 0 ;
46258   Dali::NativeImage result;
46259
46260   arg1 = (NativeImageInterface *)jarg1;
46261   if (!arg1) {
46262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46263     return 0;
46264   }
46265   {
46266     try {
46267       result = Dali::NativeImage::New(*arg1);
46268     } catch (std::out_of_range& e) {
46269       {
46270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46271       };
46272     } catch (std::exception& e) {
46273       {
46274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46275       };
46276     } catch (Dali::DaliException e) {
46277       {
46278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46279       };
46280     } catch (...) {
46281       {
46282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46283       };
46284     }
46285   }
46286
46287   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46288   return jresult;
46289 }
46290
46291
46292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46293   void * jresult ;
46294   Dali::BaseHandle arg1 ;
46295   Dali::BaseHandle *argp1 ;
46296   Dali::NativeImage result;
46297
46298   argp1 = (Dali::BaseHandle *)jarg1;
46299   if (!argp1) {
46300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46301     return 0;
46302   }
46303   arg1 = *argp1;
46304   {
46305     try {
46306       result = Dali::NativeImage::DownCast(arg1);
46307     } catch (std::out_of_range& e) {
46308       {
46309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46310       };
46311     } catch (std::exception& e) {
46312       {
46313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46314       };
46315     } catch (Dali::DaliException e) {
46316       {
46317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46318       };
46319     } catch (...) {
46320       {
46321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46322       };
46323     }
46324   }
46325
46326   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46327   return jresult;
46328 }
46329
46330
46331 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46332   char * jresult ;
46333   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46334   char *result = 0 ;
46335
46336   arg1 = (Dali::NativeImage *)jarg1;
46337   {
46338     try {
46339       result = (char *)(arg1)->GetCustomFragmentPreFix();
46340     } catch (std::out_of_range& e) {
46341       {
46342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46343       };
46344     } catch (std::exception& e) {
46345       {
46346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46347       };
46348     } catch (Dali::DaliException e) {
46349       {
46350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46351       };
46352     } catch (...) {
46353       {
46354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46355       };
46356     }
46357   }
46358
46359   jresult = SWIG_csharp_string_callback((const char *)result);
46360   return jresult;
46361 }
46362
46363
46364 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46365   char * jresult ;
46366   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46367   char *result = 0 ;
46368
46369   arg1 = (Dali::NativeImage *)jarg1;
46370   {
46371     try {
46372       result = (char *)(arg1)->GetCustomSamplerTypename();
46373     } catch (std::out_of_range& e) {
46374       {
46375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46376       };
46377     } catch (std::exception& e) {
46378       {
46379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46380       };
46381     } catch (Dali::DaliException e) {
46382       {
46383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46384       };
46385     } catch (...) {
46386       {
46387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46388       };
46389     }
46390   }
46391
46392   jresult = SWIG_csharp_string_callback((const char *)result);
46393   return jresult;
46394 }
46395
46396
46397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46398   unsigned int jresult ;
46399   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46400   bool result;
46401
46402   arg1 = (Dali::NativeImageInterface *)jarg1;
46403   {
46404     try {
46405       result = (bool)(arg1)->GlExtensionCreate();
46406     } catch (std::out_of_range& e) {
46407       {
46408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46409       };
46410     } catch (std::exception& e) {
46411       {
46412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46413       };
46414     } catch (Dali::DaliException e) {
46415       {
46416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46417       };
46418     } catch (...) {
46419       {
46420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46421       };
46422     }
46423   }
46424
46425   jresult = result;
46426   return jresult;
46427 }
46428
46429
46430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46431   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46432
46433   arg1 = (Dali::NativeImageInterface *)jarg1;
46434   {
46435     try {
46436       (arg1)->GlExtensionDestroy();
46437     } catch (std::out_of_range& e) {
46438       {
46439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46440       };
46441     } catch (std::exception& e) {
46442       {
46443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46444       };
46445     } catch (Dali::DaliException e) {
46446       {
46447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46448       };
46449     } catch (...) {
46450       {
46451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46452       };
46453     }
46454   }
46455
46456 }
46457
46458
46459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46460   unsigned int jresult ;
46461   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46462   unsigned int result;
46463
46464   arg1 = (Dali::NativeImageInterface *)jarg1;
46465   {
46466     try {
46467       result = (unsigned int)(arg1)->TargetTexture();
46468     } catch (std::out_of_range& e) {
46469       {
46470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46471       };
46472     } catch (std::exception& e) {
46473       {
46474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46475       };
46476     } catch (Dali::DaliException e) {
46477       {
46478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46479       };
46480     } catch (...) {
46481       {
46482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46483       };
46484     }
46485   }
46486
46487   jresult = result;
46488   return jresult;
46489 }
46490
46491
46492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46493   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46494
46495   arg1 = (Dali::NativeImageInterface *)jarg1;
46496   {
46497     try {
46498       (arg1)->PrepareTexture();
46499     } catch (std::out_of_range& e) {
46500       {
46501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46502       };
46503     } catch (std::exception& e) {
46504       {
46505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46506       };
46507     } catch (Dali::DaliException e) {
46508       {
46509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46510       };
46511     } catch (...) {
46512       {
46513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46514       };
46515     }
46516   }
46517
46518 }
46519
46520
46521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46522   unsigned int jresult ;
46523   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46524   unsigned int result;
46525
46526   arg1 = (Dali::NativeImageInterface *)jarg1;
46527   {
46528     try {
46529       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46530     } catch (std::out_of_range& e) {
46531       {
46532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46533       };
46534     } catch (std::exception& e) {
46535       {
46536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46537       };
46538     } catch (Dali::DaliException e) {
46539       {
46540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46541       };
46542     } catch (...) {
46543       {
46544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46545       };
46546     }
46547   }
46548
46549   jresult = result;
46550   return jresult;
46551 }
46552
46553
46554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46555   unsigned int jresult ;
46556   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46557   unsigned int result;
46558
46559   arg1 = (Dali::NativeImageInterface *)jarg1;
46560   {
46561     try {
46562       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46563     } catch (std::out_of_range& e) {
46564       {
46565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46566       };
46567     } catch (std::exception& e) {
46568       {
46569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46570       };
46571     } catch (Dali::DaliException e) {
46572       {
46573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46574       };
46575     } catch (...) {
46576       {
46577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46578       };
46579     }
46580   }
46581
46582   jresult = result;
46583   return jresult;
46584 }
46585
46586
46587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46588   unsigned int jresult ;
46589   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46590   bool result;
46591
46592   arg1 = (Dali::NativeImageInterface *)jarg1;
46593   {
46594     try {
46595       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46596     } catch (std::out_of_range& e) {
46597       {
46598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46599       };
46600     } catch (std::exception& e) {
46601       {
46602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46603       };
46604     } catch (Dali::DaliException e) {
46605       {
46606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46607       };
46608     } catch (...) {
46609       {
46610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46611       };
46612     }
46613   }
46614
46615   jresult = result;
46616   return jresult;
46617 }
46618
46619
46620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46621   void * jresult ;
46622   std::string *arg1 = 0 ;
46623   Dali::ImageDimensions result;
46624
46625   if (!jarg1) {
46626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46627     return 0;
46628   }
46629   std::string arg1_str(jarg1);
46630   arg1 = &arg1_str;
46631   {
46632     try {
46633       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46634     } catch (std::out_of_range& e) {
46635       {
46636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46637       };
46638     } catch (std::exception& e) {
46639       {
46640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46641       };
46642     } catch (Dali::DaliException e) {
46643       {
46644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46645       };
46646     } catch (...) {
46647       {
46648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46649       };
46650     }
46651   }
46652
46653   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46654
46655   //argout typemap for const std::string&
46656
46657   return jresult;
46658 }
46659
46660
46661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46662   void * jresult ;
46663   Dali::ResourceImage *result = 0 ;
46664
46665   {
46666     try {
46667       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46668     } catch (std::out_of_range& e) {
46669       {
46670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46671       };
46672     } catch (std::exception& e) {
46673       {
46674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46675       };
46676     } catch (Dali::DaliException e) {
46677       {
46678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46679       };
46680     } catch (...) {
46681       {
46682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46683       };
46684     }
46685   }
46686
46687   jresult = (void *)result;
46688   return jresult;
46689 }
46690
46691
46692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46693   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46694
46695   arg1 = (Dali::ResourceImage *)jarg1;
46696   {
46697     try {
46698       delete arg1;
46699     } catch (std::out_of_range& e) {
46700       {
46701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46702       };
46703     } catch (std::exception& e) {
46704       {
46705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46706       };
46707     } catch (Dali::DaliException e) {
46708       {
46709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46710       };
46711     } catch (...) {
46712       {
46713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46714       };
46715     }
46716   }
46717
46718 }
46719
46720
46721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46722   void * jresult ;
46723   Dali::ResourceImage *arg1 = 0 ;
46724   Dali::ResourceImage *result = 0 ;
46725
46726   arg1 = (Dali::ResourceImage *)jarg1;
46727   if (!arg1) {
46728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46729     return 0;
46730   }
46731   {
46732     try {
46733       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46734     } catch (std::out_of_range& e) {
46735       {
46736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46737       };
46738     } catch (std::exception& e) {
46739       {
46740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46741       };
46742     } catch (Dali::DaliException e) {
46743       {
46744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46745       };
46746     } catch (...) {
46747       {
46748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46749       };
46750     }
46751   }
46752
46753   jresult = (void *)result;
46754   return jresult;
46755 }
46756
46757
46758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46759   void * jresult ;
46760   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46761   Dali::ResourceImage *arg2 = 0 ;
46762   Dali::ResourceImage *result = 0 ;
46763
46764   arg1 = (Dali::ResourceImage *)jarg1;
46765   arg2 = (Dali::ResourceImage *)jarg2;
46766   if (!arg2) {
46767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46768     return 0;
46769   }
46770   {
46771     try {
46772       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46773     } catch (std::out_of_range& e) {
46774       {
46775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46776       };
46777     } catch (std::exception& e) {
46778       {
46779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46780       };
46781     } catch (Dali::DaliException e) {
46782       {
46783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46784       };
46785     } catch (...) {
46786       {
46787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46788       };
46789     }
46790   }
46791
46792   jresult = (void *)result;
46793   return jresult;
46794 }
46795
46796
46797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46798   void * jresult ;
46799   std::string *arg1 = 0 ;
46800   bool arg2 ;
46801   Dali::ResourceImage result;
46802
46803   if (!jarg1) {
46804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46805     return 0;
46806   }
46807   std::string arg1_str(jarg1);
46808   arg1 = &arg1_str;
46809   arg2 = jarg2 ? true : false;
46810   {
46811     try {
46812       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46813     } catch (std::out_of_range& e) {
46814       {
46815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46816       };
46817     } catch (std::exception& e) {
46818       {
46819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46820       };
46821     } catch (Dali::DaliException e) {
46822       {
46823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46824       };
46825     } catch (...) {
46826       {
46827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46828       };
46829     }
46830   }
46831
46832   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46833
46834   //argout typemap for const std::string&
46835
46836   return jresult;
46837 }
46838
46839
46840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46841   void * jresult ;
46842   std::string *arg1 = 0 ;
46843   Dali::ResourceImage result;
46844
46845   if (!jarg1) {
46846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46847     return 0;
46848   }
46849   std::string arg1_str(jarg1);
46850   arg1 = &arg1_str;
46851   {
46852     try {
46853       result = Dali::ResourceImage::New((std::string const &)*arg1);
46854     } catch (std::out_of_range& e) {
46855       {
46856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46857       };
46858     } catch (std::exception& e) {
46859       {
46860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46861       };
46862     } catch (Dali::DaliException e) {
46863       {
46864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46865       };
46866     } catch (...) {
46867       {
46868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46869       };
46870     }
46871   }
46872
46873   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46874
46875   //argout typemap for const std::string&
46876
46877   return jresult;
46878 }
46879
46880
46881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46882   void * jresult ;
46883   std::string *arg1 = 0 ;
46884   Dali::ImageDimensions arg2 ;
46885   Dali::FittingMode::Type arg3 ;
46886   Dali::SamplingMode::Type arg4 ;
46887   bool arg5 ;
46888   Dali::ImageDimensions *argp2 ;
46889   Dali::ResourceImage result;
46890
46891   if (!jarg1) {
46892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46893     return 0;
46894   }
46895   std::string arg1_str(jarg1);
46896   arg1 = &arg1_str;
46897   argp2 = (Dali::ImageDimensions *)jarg2;
46898   if (!argp2) {
46899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46900     return 0;
46901   }
46902   arg2 = *argp2;
46903   arg3 = (Dali::FittingMode::Type)jarg3;
46904   arg4 = (Dali::SamplingMode::Type)jarg4;
46905   arg5 = jarg5 ? true : false;
46906   {
46907     try {
46908       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46909     } catch (std::out_of_range& e) {
46910       {
46911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46912       };
46913     } catch (std::exception& e) {
46914       {
46915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46916       };
46917     } catch (Dali::DaliException e) {
46918       {
46919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46920       };
46921     } catch (...) {
46922       {
46923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46924       };
46925     }
46926   }
46927
46928   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46929
46930   //argout typemap for const std::string&
46931
46932   return jresult;
46933 }
46934
46935
46936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46937   void * jresult ;
46938   std::string *arg1 = 0 ;
46939   Dali::ImageDimensions arg2 ;
46940   Dali::FittingMode::Type arg3 ;
46941   Dali::SamplingMode::Type arg4 ;
46942   Dali::ImageDimensions *argp2 ;
46943   Dali::ResourceImage result;
46944
46945   if (!jarg1) {
46946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46947     return 0;
46948   }
46949   std::string arg1_str(jarg1);
46950   arg1 = &arg1_str;
46951   argp2 = (Dali::ImageDimensions *)jarg2;
46952   if (!argp2) {
46953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46954     return 0;
46955   }
46956   arg2 = *argp2;
46957   arg3 = (Dali::FittingMode::Type)jarg3;
46958   arg4 = (Dali::SamplingMode::Type)jarg4;
46959   {
46960     try {
46961       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46962     } catch (std::out_of_range& e) {
46963       {
46964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46965       };
46966     } catch (std::exception& e) {
46967       {
46968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46969       };
46970     } catch (Dali::DaliException e) {
46971       {
46972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46973       };
46974     } catch (...) {
46975       {
46976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46977       };
46978     }
46979   }
46980
46981   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46982
46983   //argout typemap for const std::string&
46984
46985   return jresult;
46986 }
46987
46988
46989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46990   void * jresult ;
46991   std::string *arg1 = 0 ;
46992   Dali::ImageDimensions arg2 ;
46993   Dali::FittingMode::Type arg3 ;
46994   Dali::ImageDimensions *argp2 ;
46995   Dali::ResourceImage result;
46996
46997   if (!jarg1) {
46998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46999     return 0;
47000   }
47001   std::string arg1_str(jarg1);
47002   arg1 = &arg1_str;
47003   argp2 = (Dali::ImageDimensions *)jarg2;
47004   if (!argp2) {
47005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
47006     return 0;
47007   }
47008   arg2 = *argp2;
47009   arg3 = (Dali::FittingMode::Type)jarg3;
47010   {
47011     try {
47012       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
47013     } catch (std::out_of_range& e) {
47014       {
47015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47016       };
47017     } catch (std::exception& e) {
47018       {
47019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47020       };
47021     } catch (Dali::DaliException e) {
47022       {
47023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47024       };
47025     } catch (...) {
47026       {
47027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47028       };
47029     }
47030   }
47031
47032   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47033
47034   //argout typemap for const std::string&
47035
47036   return jresult;
47037 }
47038
47039
47040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
47041   void * jresult ;
47042   std::string *arg1 = 0 ;
47043   Dali::ImageDimensions arg2 ;
47044   Dali::ImageDimensions *argp2 ;
47045   Dali::ResourceImage result;
47046
47047   if (!jarg1) {
47048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47049     return 0;
47050   }
47051   std::string arg1_str(jarg1);
47052   arg1 = &arg1_str;
47053   argp2 = (Dali::ImageDimensions *)jarg2;
47054   if (!argp2) {
47055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
47056     return 0;
47057   }
47058   arg2 = *argp2;
47059   {
47060     try {
47061       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
47062     } catch (std::out_of_range& e) {
47063       {
47064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47065       };
47066     } catch (std::exception& e) {
47067       {
47068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47069       };
47070     } catch (Dali::DaliException e) {
47071       {
47072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47073       };
47074     } catch (...) {
47075       {
47076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47077       };
47078     }
47079   }
47080
47081   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47082
47083   //argout typemap for const std::string&
47084
47085   return jresult;
47086 }
47087
47088
47089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
47090   void * jresult ;
47091   Dali::BaseHandle arg1 ;
47092   Dali::BaseHandle *argp1 ;
47093   Dali::ResourceImage result;
47094
47095   argp1 = (Dali::BaseHandle *)jarg1;
47096   if (!argp1) {
47097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47098     return 0;
47099   }
47100   arg1 = *argp1;
47101   {
47102     try {
47103       result = Dali::ResourceImage::DownCast(arg1);
47104     } catch (std::out_of_range& e) {
47105       {
47106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47107       };
47108     } catch (std::exception& e) {
47109       {
47110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47111       };
47112     } catch (Dali::DaliException e) {
47113       {
47114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47115       };
47116     } catch (...) {
47117       {
47118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47119       };
47120     }
47121   }
47122
47123   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47124   return jresult;
47125 }
47126
47127
47128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47129   int jresult ;
47130   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47131   Dali::LoadingState result;
47132
47133   arg1 = (Dali::ResourceImage *)jarg1;
47134   {
47135     try {
47136       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47137     } catch (std::out_of_range& e) {
47138       {
47139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47140       };
47141     } catch (std::exception& e) {
47142       {
47143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47144       };
47145     } catch (Dali::DaliException e) {
47146       {
47147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47148       };
47149     } catch (...) {
47150       {
47151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47152       };
47153     }
47154   }
47155
47156   jresult = (int)result;
47157   return jresult;
47158 }
47159
47160
47161 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47162   char * jresult ;
47163   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47164   std::string result;
47165
47166   arg1 = (Dali::ResourceImage *)jarg1;
47167   {
47168     try {
47169       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47170     } catch (std::out_of_range& e) {
47171       {
47172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47173       };
47174     } catch (std::exception& e) {
47175       {
47176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47177       };
47178     } catch (Dali::DaliException e) {
47179       {
47180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47181       };
47182     } catch (...) {
47183       {
47184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47185       };
47186     }
47187   }
47188
47189   jresult = SWIG_csharp_string_callback((&result)->c_str());
47190   return jresult;
47191 }
47192
47193
47194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47195   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47196
47197   arg1 = (Dali::ResourceImage *)jarg1;
47198   {
47199     try {
47200       (arg1)->Reload();
47201     } catch (std::out_of_range& e) {
47202       {
47203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47204       };
47205     } catch (std::exception& e) {
47206       {
47207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47208       };
47209     } catch (Dali::DaliException e) {
47210       {
47211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47212       };
47213     } catch (...) {
47214       {
47215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47216       };
47217     }
47218   }
47219
47220 }
47221
47222
47223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47224   void * jresult ;
47225   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47226   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47227
47228   arg1 = (Dali::ResourceImage *)jarg1;
47229   {
47230     try {
47231       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47232     } catch (std::out_of_range& e) {
47233       {
47234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47235       };
47236     } catch (std::exception& e) {
47237       {
47238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47239       };
47240     } catch (Dali::DaliException e) {
47241       {
47242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47243       };
47244     } catch (...) {
47245       {
47246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47247       };
47248     }
47249   }
47250
47251   jresult = (void *)result;
47252   return jresult;
47253 }
47254
47255
47256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47257   void * jresult ;
47258   Dali::FrameBufferImage *result = 0 ;
47259
47260   {
47261     try {
47262       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47263     } catch (std::out_of_range& e) {
47264       {
47265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47266       };
47267     } catch (std::exception& e) {
47268       {
47269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47270       };
47271     } catch (Dali::DaliException e) {
47272       {
47273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47274       };
47275     } catch (...) {
47276       {
47277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47278       };
47279     }
47280   }
47281
47282   jresult = (void *)result;
47283   return jresult;
47284 }
47285
47286
47287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47288   void * jresult ;
47289   unsigned int arg1 ;
47290   unsigned int arg2 ;
47291   Dali::Pixel::Format arg3 ;
47292   Dali::RenderBuffer::Format arg4 ;
47293   Dali::FrameBufferImage result;
47294
47295   arg1 = (unsigned int)jarg1;
47296   arg2 = (unsigned int)jarg2;
47297   arg3 = (Dali::Pixel::Format)jarg3;
47298   arg4 = (Dali::RenderBuffer::Format)jarg4;
47299   {
47300     try {
47301       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47302     } catch (std::out_of_range& e) {
47303       {
47304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47305       };
47306     } catch (std::exception& e) {
47307       {
47308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47309       };
47310     } catch (Dali::DaliException e) {
47311       {
47312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47313       };
47314     } catch (...) {
47315       {
47316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47317       };
47318     }
47319   }
47320
47321   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47322   return jresult;
47323 }
47324
47325
47326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47327   void * jresult ;
47328   unsigned int arg1 ;
47329   unsigned int arg2 ;
47330   Dali::Pixel::Format arg3 ;
47331   Dali::FrameBufferImage result;
47332
47333   arg1 = (unsigned int)jarg1;
47334   arg2 = (unsigned int)jarg2;
47335   arg3 = (Dali::Pixel::Format)jarg3;
47336   {
47337     try {
47338       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47339     } catch (std::out_of_range& e) {
47340       {
47341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47342       };
47343     } catch (std::exception& e) {
47344       {
47345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47346       };
47347     } catch (Dali::DaliException e) {
47348       {
47349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47350       };
47351     } catch (...) {
47352       {
47353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47354       };
47355     }
47356   }
47357
47358   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47359   return jresult;
47360 }
47361
47362
47363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47364   void * jresult ;
47365   unsigned int arg1 ;
47366   unsigned int arg2 ;
47367   Dali::FrameBufferImage result;
47368
47369   arg1 = (unsigned int)jarg1;
47370   arg2 = (unsigned int)jarg2;
47371   {
47372     try {
47373       result = Dali::FrameBufferImage::New(arg1,arg2);
47374     } catch (std::out_of_range& e) {
47375       {
47376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47377       };
47378     } catch (std::exception& e) {
47379       {
47380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47381       };
47382     } catch (Dali::DaliException e) {
47383       {
47384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47385       };
47386     } catch (...) {
47387       {
47388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47389       };
47390     }
47391   }
47392
47393   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47394   return jresult;
47395 }
47396
47397
47398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47399   void * jresult ;
47400   unsigned int arg1 ;
47401   Dali::FrameBufferImage result;
47402
47403   arg1 = (unsigned int)jarg1;
47404   {
47405     try {
47406       result = Dali::FrameBufferImage::New(arg1);
47407     } catch (std::out_of_range& e) {
47408       {
47409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47410       };
47411     } catch (std::exception& e) {
47412       {
47413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47414       };
47415     } catch (Dali::DaliException e) {
47416       {
47417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47418       };
47419     } catch (...) {
47420       {
47421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47422       };
47423     }
47424   }
47425
47426   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47427   return jresult;
47428 }
47429
47430
47431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47432   void * jresult ;
47433   Dali::FrameBufferImage result;
47434
47435   {
47436     try {
47437       result = Dali::FrameBufferImage::New();
47438     } catch (std::out_of_range& e) {
47439       {
47440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47441       };
47442     } catch (std::exception& e) {
47443       {
47444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47445       };
47446     } catch (Dali::DaliException e) {
47447       {
47448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47449       };
47450     } catch (...) {
47451       {
47452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47453       };
47454     }
47455   }
47456
47457   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47458   return jresult;
47459 }
47460
47461
47462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47463   void * jresult ;
47464   Dali::NativeImageInterface *arg1 = 0 ;
47465   Dali::FrameBufferImage result;
47466
47467   arg1 = (Dali::NativeImageInterface *)jarg1;
47468   if (!arg1) {
47469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47470     return 0;
47471   }
47472   {
47473     try {
47474       result = Dali::FrameBufferImage::New(*arg1);
47475     } catch (std::out_of_range& e) {
47476       {
47477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47478       };
47479     } catch (std::exception& e) {
47480       {
47481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47482       };
47483     } catch (Dali::DaliException e) {
47484       {
47485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47486       };
47487     } catch (...) {
47488       {
47489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47490       };
47491     }
47492   }
47493
47494   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47495   return jresult;
47496 }
47497
47498
47499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47500   void * jresult ;
47501   Dali::BaseHandle arg1 ;
47502   Dali::BaseHandle *argp1 ;
47503   Dali::FrameBufferImage result;
47504
47505   argp1 = (Dali::BaseHandle *)jarg1;
47506   if (!argp1) {
47507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47508     return 0;
47509   }
47510   arg1 = *argp1;
47511   {
47512     try {
47513       result = Dali::FrameBufferImage::DownCast(arg1);
47514     } catch (std::out_of_range& e) {
47515       {
47516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47517       };
47518     } catch (std::exception& e) {
47519       {
47520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47521       };
47522     } catch (Dali::DaliException e) {
47523       {
47524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47525       };
47526     } catch (...) {
47527       {
47528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47529       };
47530     }
47531   }
47532
47533   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47534   return jresult;
47535 }
47536
47537
47538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47539   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47540
47541   arg1 = (Dali::FrameBufferImage *)jarg1;
47542   {
47543     try {
47544       delete arg1;
47545     } catch (std::out_of_range& e) {
47546       {
47547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47548       };
47549     } catch (std::exception& e) {
47550       {
47551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47552       };
47553     } catch (Dali::DaliException e) {
47554       {
47555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47556       };
47557     } catch (...) {
47558       {
47559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47560       };
47561     }
47562   }
47563
47564 }
47565
47566
47567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47568   void * jresult ;
47569   Dali::FrameBufferImage *arg1 = 0 ;
47570   Dali::FrameBufferImage *result = 0 ;
47571
47572   arg1 = (Dali::FrameBufferImage *)jarg1;
47573   if (!arg1) {
47574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47575     return 0;
47576   }
47577   {
47578     try {
47579       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47580     } catch (std::out_of_range& e) {
47581       {
47582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47583       };
47584     } catch (std::exception& e) {
47585       {
47586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47587       };
47588     } catch (Dali::DaliException e) {
47589       {
47590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47591       };
47592     } catch (...) {
47593       {
47594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47595       };
47596     }
47597   }
47598
47599   jresult = (void *)result;
47600   return jresult;
47601 }
47602
47603
47604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47605   void * jresult ;
47606   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47607   Dali::FrameBufferImage *arg2 = 0 ;
47608   Dali::FrameBufferImage *result = 0 ;
47609
47610   arg1 = (Dali::FrameBufferImage *)jarg1;
47611   arg2 = (Dali::FrameBufferImage *)jarg2;
47612   if (!arg2) {
47613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47614     return 0;
47615   }
47616   {
47617     try {
47618       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47619     } catch (std::out_of_range& e) {
47620       {
47621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47622       };
47623     } catch (std::exception& e) {
47624       {
47625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47626       };
47627     } catch (Dali::DaliException e) {
47628       {
47629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47630       };
47631     } catch (...) {
47632       {
47633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47634       };
47635     }
47636   }
47637
47638   jresult = (void *)result;
47639   return jresult;
47640 }
47641
47642
47643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47644   void * jresult ;
47645   Dali::NinePatchImage *result = 0 ;
47646
47647   {
47648     try {
47649       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47650     } catch (std::out_of_range& e) {
47651       {
47652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47653       };
47654     } catch (std::exception& e) {
47655       {
47656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47657       };
47658     } catch (Dali::DaliException e) {
47659       {
47660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47661       };
47662     } catch (...) {
47663       {
47664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47665       };
47666     }
47667   }
47668
47669   jresult = (void *)result;
47670   return jresult;
47671 }
47672
47673
47674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47675   void * jresult ;
47676   std::string *arg1 = 0 ;
47677   Dali::NinePatchImage result;
47678
47679   if (!jarg1) {
47680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47681     return 0;
47682   }
47683   std::string arg1_str(jarg1);
47684   arg1 = &arg1_str;
47685   {
47686     try {
47687       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47688     } catch (std::out_of_range& e) {
47689       {
47690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47691       };
47692     } catch (std::exception& e) {
47693       {
47694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47695       };
47696     } catch (Dali::DaliException e) {
47697       {
47698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47699       };
47700     } catch (...) {
47701       {
47702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47703       };
47704     }
47705   }
47706
47707   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47708
47709   //argout typemap for const std::string&
47710
47711   return jresult;
47712 }
47713
47714
47715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47716   void * jresult ;
47717   Dali::BaseHandle arg1 ;
47718   Dali::BaseHandle *argp1 ;
47719   Dali::NinePatchImage result;
47720
47721   argp1 = (Dali::BaseHandle *)jarg1;
47722   if (!argp1) {
47723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47724     return 0;
47725   }
47726   arg1 = *argp1;
47727   {
47728     try {
47729       result = Dali::NinePatchImage::DownCast(arg1);
47730     } catch (std::out_of_range& e) {
47731       {
47732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47733       };
47734     } catch (std::exception& e) {
47735       {
47736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47737       };
47738     } catch (Dali::DaliException e) {
47739       {
47740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47741       };
47742     } catch (...) {
47743       {
47744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47745       };
47746     }
47747   }
47748
47749   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47750   return jresult;
47751 }
47752
47753
47754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47755   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47756
47757   arg1 = (Dali::NinePatchImage *)jarg1;
47758   {
47759     try {
47760       delete arg1;
47761     } catch (std::out_of_range& e) {
47762       {
47763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47764       };
47765     } catch (std::exception& e) {
47766       {
47767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47768       };
47769     } catch (Dali::DaliException e) {
47770       {
47771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47772       };
47773     } catch (...) {
47774       {
47775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47776       };
47777     }
47778   }
47779
47780 }
47781
47782
47783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47784   void * jresult ;
47785   Dali::NinePatchImage *arg1 = 0 ;
47786   Dali::NinePatchImage *result = 0 ;
47787
47788   arg1 = (Dali::NinePatchImage *)jarg1;
47789   if (!arg1) {
47790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47791     return 0;
47792   }
47793   {
47794     try {
47795       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47796     } catch (std::out_of_range& e) {
47797       {
47798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47799       };
47800     } catch (std::exception& e) {
47801       {
47802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47803       };
47804     } catch (Dali::DaliException e) {
47805       {
47806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47807       };
47808     } catch (...) {
47809       {
47810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47811       };
47812     }
47813   }
47814
47815   jresult = (void *)result;
47816   return jresult;
47817 }
47818
47819
47820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47821   void * jresult ;
47822   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47823   Dali::NinePatchImage *arg2 = 0 ;
47824   Dali::NinePatchImage *result = 0 ;
47825
47826   arg1 = (Dali::NinePatchImage *)jarg1;
47827   arg2 = (Dali::NinePatchImage *)jarg2;
47828   if (!arg2) {
47829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47830     return 0;
47831   }
47832   {
47833     try {
47834       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47835     } catch (std::out_of_range& e) {
47836       {
47837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47838       };
47839     } catch (std::exception& e) {
47840       {
47841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47842       };
47843     } catch (Dali::DaliException e) {
47844       {
47845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47846       };
47847     } catch (...) {
47848       {
47849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47850       };
47851     }
47852   }
47853
47854   jresult = (void *)result;
47855   return jresult;
47856 }
47857
47858
47859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47860   void * jresult ;
47861   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47862   Dali::Vector4 result;
47863
47864   arg1 = (Dali::NinePatchImage *)jarg1;
47865   {
47866     try {
47867       result = (arg1)->GetStretchBorders();
47868     } catch (std::out_of_range& e) {
47869       {
47870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47871       };
47872     } catch (std::exception& e) {
47873       {
47874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47875       };
47876     } catch (Dali::DaliException e) {
47877       {
47878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47879       };
47880     } catch (...) {
47881       {
47882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47883       };
47884     }
47885   }
47886
47887   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47888   return jresult;
47889 }
47890
47891
47892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47893   void * jresult ;
47894   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47895   Dali::NinePatchImage::StretchRanges *result = 0 ;
47896
47897   arg1 = (Dali::NinePatchImage *)jarg1;
47898   {
47899     try {
47900       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47901     } catch (std::out_of_range& e) {
47902       {
47903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47904       };
47905     } catch (std::exception& e) {
47906       {
47907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47908       };
47909     } catch (Dali::DaliException e) {
47910       {
47911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47912       };
47913     } catch (...) {
47914       {
47915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47916       };
47917     }
47918   }
47919
47920   jresult = (void *)result;
47921   return jresult;
47922 }
47923
47924
47925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47926   void * jresult ;
47927   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47928   Dali::NinePatchImage::StretchRanges *result = 0 ;
47929
47930   arg1 = (Dali::NinePatchImage *)jarg1;
47931   {
47932     try {
47933       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47934     } catch (std::out_of_range& e) {
47935       {
47936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47937       };
47938     } catch (std::exception& e) {
47939       {
47940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47941       };
47942     } catch (Dali::DaliException e) {
47943       {
47944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47945       };
47946     } catch (...) {
47947       {
47948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47949       };
47950     }
47951   }
47952
47953   jresult = (void *)result;
47954   return jresult;
47955 }
47956
47957
47958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47959   void * jresult ;
47960   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47961   Dali::Rect< int > result;
47962
47963   arg1 = (Dali::NinePatchImage *)jarg1;
47964   {
47965     try {
47966       result = (arg1)->GetChildRectangle();
47967     } catch (std::out_of_range& e) {
47968       {
47969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47970       };
47971     } catch (std::exception& e) {
47972       {
47973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47974       };
47975     } catch (Dali::DaliException e) {
47976       {
47977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47978       };
47979     } catch (...) {
47980       {
47981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47982       };
47983     }
47984   }
47985
47986   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47987   return jresult;
47988 }
47989
47990
47991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47992   void * jresult ;
47993   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47994   Dali::BufferImage result;
47995
47996   arg1 = (Dali::NinePatchImage *)jarg1;
47997   {
47998     try {
47999       result = (arg1)->CreateCroppedBufferImage();
48000     } catch (std::out_of_range& e) {
48001       {
48002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48003       };
48004     } catch (std::exception& e) {
48005       {
48006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48007       };
48008     } catch (Dali::DaliException e) {
48009       {
48010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48011       };
48012     } catch (...) {
48013       {
48014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48015       };
48016     }
48017   }
48018
48019   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
48020   return jresult;
48021 }
48022
48023
48024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
48025   unsigned int jresult ;
48026   std::string *arg1 = 0 ;
48027   bool result;
48028
48029   if (!jarg1) {
48030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48031     return 0;
48032   }
48033   std::string arg1_str(jarg1);
48034   arg1 = &arg1_str;
48035   {
48036     try {
48037       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
48038     } catch (std::out_of_range& e) {
48039       {
48040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48041       };
48042     } catch (std::exception& e) {
48043       {
48044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48045       };
48046     } catch (Dali::DaliException e) {
48047       {
48048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48049       };
48050     } catch (...) {
48051       {
48052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48053       };
48054     }
48055   }
48056
48057   jresult = result;
48058
48059   //argout typemap for const std::string&
48060
48061   return jresult;
48062 }
48063
48064
48065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
48066   int jresult ;
48067   int result;
48068
48069   result = (int)Dali::CameraActor::Property::TYPE;
48070   jresult = (int)result;
48071   return jresult;
48072 }
48073
48074
48075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
48076   int jresult ;
48077   int result;
48078
48079   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
48080   jresult = (int)result;
48081   return jresult;
48082 }
48083
48084
48085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
48086   int jresult ;
48087   int result;
48088
48089   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
48090   jresult = (int)result;
48091   return jresult;
48092 }
48093
48094
48095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
48096   int jresult ;
48097   int result;
48098
48099   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
48100   jresult = (int)result;
48101   return jresult;
48102 }
48103
48104
48105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
48106   int jresult ;
48107   int result;
48108
48109   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
48110   jresult = (int)result;
48111   return jresult;
48112 }
48113
48114
48115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48116   int jresult ;
48117   int result;
48118
48119   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48120   jresult = (int)result;
48121   return jresult;
48122 }
48123
48124
48125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48126   int jresult ;
48127   int result;
48128
48129   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48130   jresult = (int)result;
48131   return jresult;
48132 }
48133
48134
48135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48136   int jresult ;
48137   int result;
48138
48139   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48140   jresult = (int)result;
48141   return jresult;
48142 }
48143
48144
48145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48146   int jresult ;
48147   int result;
48148
48149   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48150   jresult = (int)result;
48151   return jresult;
48152 }
48153
48154
48155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48156   int jresult ;
48157   int result;
48158
48159   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48160   jresult = (int)result;
48161   return jresult;
48162 }
48163
48164
48165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48166   int jresult ;
48167   int result;
48168
48169   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48170   jresult = (int)result;
48171   return jresult;
48172 }
48173
48174
48175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48176   int jresult ;
48177   int result;
48178
48179   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48180   jresult = (int)result;
48181   return jresult;
48182 }
48183
48184
48185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48186   int jresult ;
48187   int result;
48188
48189   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48190   jresult = (int)result;
48191   return jresult;
48192 }
48193
48194
48195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48196   int jresult ;
48197   int result;
48198
48199   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48200   jresult = (int)result;
48201   return jresult;
48202 }
48203
48204
48205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48206   void * jresult ;
48207   Dali::CameraActor::Property *result = 0 ;
48208
48209   {
48210     try {
48211       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48212     } catch (std::out_of_range& e) {
48213       {
48214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48215       };
48216     } catch (std::exception& e) {
48217       {
48218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48219       };
48220     } catch (Dali::DaliException e) {
48221       {
48222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48223       };
48224     } catch (...) {
48225       {
48226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48227       };
48228     }
48229   }
48230
48231   jresult = (void *)result;
48232   return jresult;
48233 }
48234
48235
48236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48237   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48238
48239   arg1 = (Dali::CameraActor::Property *)jarg1;
48240   {
48241     try {
48242       delete arg1;
48243     } catch (std::out_of_range& e) {
48244       {
48245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48246       };
48247     } catch (std::exception& e) {
48248       {
48249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48250       };
48251     } catch (Dali::DaliException e) {
48252       {
48253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48254       };
48255     } catch (...) {
48256       {
48257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48258       };
48259     }
48260   }
48261
48262 }
48263
48264
48265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48266   void * jresult ;
48267   Dali::CameraActor *result = 0 ;
48268
48269   {
48270     try {
48271       result = (Dali::CameraActor *)new Dali::CameraActor();
48272     } catch (std::out_of_range& e) {
48273       {
48274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48275       };
48276     } catch (std::exception& e) {
48277       {
48278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48279       };
48280     } catch (Dali::DaliException e) {
48281       {
48282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48283       };
48284     } catch (...) {
48285       {
48286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48287       };
48288     }
48289   }
48290
48291   jresult = (void *)result;
48292   return jresult;
48293 }
48294
48295
48296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48297   void * jresult ;
48298   Dali::CameraActor result;
48299
48300   {
48301     try {
48302       result = Dali::CameraActor::New();
48303     } catch (std::out_of_range& e) {
48304       {
48305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48306       };
48307     } catch (std::exception& e) {
48308       {
48309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48310       };
48311     } catch (Dali::DaliException e) {
48312       {
48313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48314       };
48315     } catch (...) {
48316       {
48317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48318       };
48319     }
48320   }
48321
48322   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48323   return jresult;
48324 }
48325
48326
48327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48328   void * jresult ;
48329   Dali::Size *arg1 = 0 ;
48330   Dali::CameraActor result;
48331
48332   arg1 = (Dali::Size *)jarg1;
48333   if (!arg1) {
48334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48335     return 0;
48336   }
48337   {
48338     try {
48339       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48340     } catch (std::out_of_range& e) {
48341       {
48342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48343       };
48344     } catch (std::exception& e) {
48345       {
48346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48347       };
48348     } catch (Dali::DaliException e) {
48349       {
48350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48351       };
48352     } catch (...) {
48353       {
48354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48355       };
48356     }
48357   }
48358
48359   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48360   return jresult;
48361 }
48362
48363
48364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48365   void * jresult ;
48366   Dali::BaseHandle arg1 ;
48367   Dali::BaseHandle *argp1 ;
48368   Dali::CameraActor result;
48369
48370   argp1 = (Dali::BaseHandle *)jarg1;
48371   if (!argp1) {
48372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48373     return 0;
48374   }
48375   arg1 = *argp1;
48376   {
48377     try {
48378       result = Dali::CameraActor::DownCast(arg1);
48379     } catch (std::out_of_range& e) {
48380       {
48381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48382       };
48383     } catch (std::exception& e) {
48384       {
48385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48386       };
48387     } catch (Dali::DaliException e) {
48388       {
48389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48390       };
48391     } catch (...) {
48392       {
48393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48394       };
48395     }
48396   }
48397
48398   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48399   return jresult;
48400 }
48401
48402
48403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48404   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48405
48406   arg1 = (Dali::CameraActor *)jarg1;
48407   {
48408     try {
48409       delete arg1;
48410     } catch (std::out_of_range& e) {
48411       {
48412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48413       };
48414     } catch (std::exception& e) {
48415       {
48416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48417       };
48418     } catch (Dali::DaliException e) {
48419       {
48420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48421       };
48422     } catch (...) {
48423       {
48424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48425       };
48426     }
48427   }
48428
48429 }
48430
48431
48432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48433   void * jresult ;
48434   Dali::CameraActor *arg1 = 0 ;
48435   Dali::CameraActor *result = 0 ;
48436
48437   arg1 = (Dali::CameraActor *)jarg1;
48438   if (!arg1) {
48439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48440     return 0;
48441   }
48442   {
48443     try {
48444       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48445     } catch (std::out_of_range& e) {
48446       {
48447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48448       };
48449     } catch (std::exception& e) {
48450       {
48451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48452       };
48453     } catch (Dali::DaliException e) {
48454       {
48455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48456       };
48457     } catch (...) {
48458       {
48459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48460       };
48461     }
48462   }
48463
48464   jresult = (void *)result;
48465   return jresult;
48466 }
48467
48468
48469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48470   void * jresult ;
48471   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48472   Dali::CameraActor *arg2 = 0 ;
48473   Dali::CameraActor *result = 0 ;
48474
48475   arg1 = (Dali::CameraActor *)jarg1;
48476   arg2 = (Dali::CameraActor *)jarg2;
48477   if (!arg2) {
48478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48479     return 0;
48480   }
48481   {
48482     try {
48483       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48484     } catch (std::out_of_range& e) {
48485       {
48486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48487       };
48488     } catch (std::exception& e) {
48489       {
48490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48491       };
48492     } catch (Dali::DaliException e) {
48493       {
48494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48495       };
48496     } catch (...) {
48497       {
48498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48499       };
48500     }
48501   }
48502
48503   jresult = (void *)result;
48504   return jresult;
48505 }
48506
48507
48508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48509   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48510   Dali::Camera::Type arg2 ;
48511
48512   arg1 = (Dali::CameraActor *)jarg1;
48513   arg2 = (Dali::Camera::Type)jarg2;
48514   {
48515     try {
48516       (arg1)->SetType(arg2);
48517     } catch (std::out_of_range& e) {
48518       {
48519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48520       };
48521     } catch (std::exception& e) {
48522       {
48523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48524       };
48525     } catch (Dali::DaliException e) {
48526       {
48527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48528       };
48529     } catch (...) {
48530       {
48531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48532       };
48533     }
48534   }
48535
48536 }
48537
48538
48539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48540   int jresult ;
48541   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48542   Dali::Camera::Type result;
48543
48544   arg1 = (Dali::CameraActor *)jarg1;
48545   {
48546     try {
48547       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48548     } catch (std::out_of_range& e) {
48549       {
48550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48551       };
48552     } catch (std::exception& e) {
48553       {
48554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48555       };
48556     } catch (Dali::DaliException e) {
48557       {
48558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48559       };
48560     } catch (...) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48563       };
48564     }
48565   }
48566
48567   jresult = (int)result;
48568   return jresult;
48569 }
48570
48571
48572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48573   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48574   Dali::Camera::ProjectionMode arg2 ;
48575
48576   arg1 = (Dali::CameraActor *)jarg1;
48577   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48578   {
48579     try {
48580       (arg1)->SetProjectionMode(arg2);
48581     } catch (std::out_of_range& e) {
48582       {
48583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48584       };
48585     } catch (std::exception& e) {
48586       {
48587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48588       };
48589     } catch (Dali::DaliException e) {
48590       {
48591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48592       };
48593     } catch (...) {
48594       {
48595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48596       };
48597     }
48598   }
48599
48600 }
48601
48602
48603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48604   int jresult ;
48605   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48606   Dali::Camera::ProjectionMode result;
48607
48608   arg1 = (Dali::CameraActor *)jarg1;
48609   {
48610     try {
48611       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48612     } catch (std::out_of_range& e) {
48613       {
48614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48615       };
48616     } catch (std::exception& e) {
48617       {
48618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48619       };
48620     } catch (Dali::DaliException e) {
48621       {
48622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48623       };
48624     } catch (...) {
48625       {
48626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48627       };
48628     }
48629   }
48630
48631   jresult = (int)result;
48632   return jresult;
48633 }
48634
48635
48636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48637   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48638   float arg2 ;
48639
48640   arg1 = (Dali::CameraActor *)jarg1;
48641   arg2 = (float)jarg2;
48642   {
48643     try {
48644       (arg1)->SetFieldOfView(arg2);
48645     } catch (std::out_of_range& e) {
48646       {
48647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48648       };
48649     } catch (std::exception& e) {
48650       {
48651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48652       };
48653     } catch (Dali::DaliException e) {
48654       {
48655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48656       };
48657     } catch (...) {
48658       {
48659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48660       };
48661     }
48662   }
48663
48664 }
48665
48666
48667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48668   float jresult ;
48669   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48670   float result;
48671
48672   arg1 = (Dali::CameraActor *)jarg1;
48673   {
48674     try {
48675       result = (float)(arg1)->GetFieldOfView();
48676     } catch (std::out_of_range& e) {
48677       {
48678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48679       };
48680     } catch (std::exception& e) {
48681       {
48682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48683       };
48684     } catch (Dali::DaliException e) {
48685       {
48686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48687       };
48688     } catch (...) {
48689       {
48690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48691       };
48692     }
48693   }
48694
48695   jresult = result;
48696   return jresult;
48697 }
48698
48699
48700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48701   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48702   float arg2 ;
48703
48704   arg1 = (Dali::CameraActor *)jarg1;
48705   arg2 = (float)jarg2;
48706   {
48707     try {
48708       (arg1)->SetAspectRatio(arg2);
48709     } catch (std::out_of_range& e) {
48710       {
48711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48712       };
48713     } catch (std::exception& e) {
48714       {
48715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48716       };
48717     } catch (Dali::DaliException e) {
48718       {
48719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48720       };
48721     } catch (...) {
48722       {
48723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48724       };
48725     }
48726   }
48727
48728 }
48729
48730
48731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48732   float jresult ;
48733   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48734   float result;
48735
48736   arg1 = (Dali::CameraActor *)jarg1;
48737   {
48738     try {
48739       result = (float)(arg1)->GetAspectRatio();
48740     } catch (std::out_of_range& e) {
48741       {
48742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48743       };
48744     } catch (std::exception& e) {
48745       {
48746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48747       };
48748     } catch (Dali::DaliException e) {
48749       {
48750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48751       };
48752     } catch (...) {
48753       {
48754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48755       };
48756     }
48757   }
48758
48759   jresult = result;
48760   return jresult;
48761 }
48762
48763
48764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48765   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48766   float arg2 ;
48767
48768   arg1 = (Dali::CameraActor *)jarg1;
48769   arg2 = (float)jarg2;
48770   {
48771     try {
48772       (arg1)->SetNearClippingPlane(arg2);
48773     } catch (std::out_of_range& e) {
48774       {
48775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48776       };
48777     } catch (std::exception& e) {
48778       {
48779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48780       };
48781     } catch (Dali::DaliException e) {
48782       {
48783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48784       };
48785     } catch (...) {
48786       {
48787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48788       };
48789     }
48790   }
48791
48792 }
48793
48794
48795 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48796   float jresult ;
48797   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48798   float result;
48799
48800   arg1 = (Dali::CameraActor *)jarg1;
48801   {
48802     try {
48803       result = (float)(arg1)->GetNearClippingPlane();
48804     } catch (std::out_of_range& e) {
48805       {
48806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48807       };
48808     } catch (std::exception& e) {
48809       {
48810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48811       };
48812     } catch (Dali::DaliException e) {
48813       {
48814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48815       };
48816     } catch (...) {
48817       {
48818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48819       };
48820     }
48821   }
48822
48823   jresult = result;
48824   return jresult;
48825 }
48826
48827
48828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48829   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48830   float arg2 ;
48831
48832   arg1 = (Dali::CameraActor *)jarg1;
48833   arg2 = (float)jarg2;
48834   {
48835     try {
48836       (arg1)->SetFarClippingPlane(arg2);
48837     } catch (std::out_of_range& e) {
48838       {
48839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48840       };
48841     } catch (std::exception& e) {
48842       {
48843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48844       };
48845     } catch (Dali::DaliException e) {
48846       {
48847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48848       };
48849     } catch (...) {
48850       {
48851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48852       };
48853     }
48854   }
48855
48856 }
48857
48858
48859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48860   float jresult ;
48861   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48862   float result;
48863
48864   arg1 = (Dali::CameraActor *)jarg1;
48865   {
48866     try {
48867       result = (float)(arg1)->GetFarClippingPlane();
48868     } catch (std::out_of_range& e) {
48869       {
48870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48871       };
48872     } catch (std::exception& e) {
48873       {
48874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48875       };
48876     } catch (Dali::DaliException e) {
48877       {
48878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48879       };
48880     } catch (...) {
48881       {
48882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48883       };
48884     }
48885   }
48886
48887   jresult = result;
48888   return jresult;
48889 }
48890
48891
48892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48893   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48894   Dali::Vector3 *arg2 = 0 ;
48895
48896   arg1 = (Dali::CameraActor *)jarg1;
48897   arg2 = (Dali::Vector3 *)jarg2;
48898   if (!arg2) {
48899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48900     return ;
48901   }
48902   {
48903     try {
48904       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48905     } catch (std::out_of_range& e) {
48906       {
48907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48908       };
48909     } catch (std::exception& e) {
48910       {
48911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48912       };
48913     } catch (Dali::DaliException e) {
48914       {
48915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48916       };
48917     } catch (...) {
48918       {
48919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48920       };
48921     }
48922   }
48923
48924 }
48925
48926
48927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48928   void * jresult ;
48929   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48930   Dali::Vector3 result;
48931
48932   arg1 = (Dali::CameraActor *)jarg1;
48933   {
48934     try {
48935       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48936     } catch (std::out_of_range& e) {
48937       {
48938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48939       };
48940     } catch (std::exception& e) {
48941       {
48942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48943       };
48944     } catch (Dali::DaliException e) {
48945       {
48946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48947       };
48948     } catch (...) {
48949       {
48950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48951       };
48952     }
48953   }
48954
48955   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48956   return jresult;
48957 }
48958
48959
48960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48961   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48962   bool arg2 ;
48963
48964   arg1 = (Dali::CameraActor *)jarg1;
48965   arg2 = jarg2 ? true : false;
48966   {
48967     try {
48968       (arg1)->SetInvertYAxis(arg2);
48969     } catch (std::out_of_range& e) {
48970       {
48971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48972       };
48973     } catch (std::exception& e) {
48974       {
48975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48976       };
48977     } catch (Dali::DaliException e) {
48978       {
48979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48980       };
48981     } catch (...) {
48982       {
48983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48984       };
48985     }
48986   }
48987
48988 }
48989
48990
48991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48992   unsigned int jresult ;
48993   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48994   bool result;
48995
48996   arg1 = (Dali::CameraActor *)jarg1;
48997   {
48998     try {
48999       result = (bool)(arg1)->GetInvertYAxis();
49000     } catch (std::out_of_range& e) {
49001       {
49002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49003       };
49004     } catch (std::exception& e) {
49005       {
49006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49007       };
49008     } catch (Dali::DaliException e) {
49009       {
49010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49011       };
49012     } catch (...) {
49013       {
49014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49015       };
49016     }
49017   }
49018
49019   jresult = result;
49020   return jresult;
49021 }
49022
49023
49024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
49025   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49026   Dali::Size *arg2 = 0 ;
49027
49028   arg1 = (Dali::CameraActor *)jarg1;
49029   arg2 = (Dali::Size *)jarg2;
49030   if (!arg2) {
49031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
49032     return ;
49033   }
49034   {
49035     try {
49036       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
49037     } catch (std::out_of_range& e) {
49038       {
49039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49040       };
49041     } catch (std::exception& e) {
49042       {
49043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49044       };
49045     } catch (Dali::DaliException e) {
49046       {
49047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49048       };
49049     } catch (...) {
49050       {
49051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49052       };
49053     }
49054   }
49055
49056 }
49057
49058
49059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
49060   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49061   Dali::Size *arg2 = 0 ;
49062
49063   arg1 = (Dali::CameraActor *)jarg1;
49064   arg2 = (Dali::Size *)jarg2;
49065   if (!arg2) {
49066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
49067     return ;
49068   }
49069   {
49070     try {
49071       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
49072     } catch (std::out_of_range& e) {
49073       {
49074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49075       };
49076     } catch (std::exception& e) {
49077       {
49078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49079       };
49080     } catch (Dali::DaliException e) {
49081       {
49082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49083       };
49084     } catch (...) {
49085       {
49086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49087       };
49088     }
49089   }
49090
49091 }
49092
49093
49094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
49095   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49096   float arg2 ;
49097   float arg3 ;
49098   float arg4 ;
49099   float arg5 ;
49100   float arg6 ;
49101   float arg7 ;
49102
49103   arg1 = (Dali::CameraActor *)jarg1;
49104   arg2 = (float)jarg2;
49105   arg3 = (float)jarg3;
49106   arg4 = (float)jarg4;
49107   arg5 = (float)jarg5;
49108   arg6 = (float)jarg6;
49109   arg7 = (float)jarg7;
49110   {
49111     try {
49112       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
49113     } catch (std::out_of_range& e) {
49114       {
49115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49116       };
49117     } catch (std::exception& e) {
49118       {
49119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49120       };
49121     } catch (Dali::DaliException e) {
49122       {
49123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49124       };
49125     } catch (...) {
49126       {
49127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49128       };
49129     }
49130   }
49131
49132 }
49133
49134
49135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49136   void * jresult ;
49137   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49138
49139   {
49140     try {
49141       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49142     } catch (std::out_of_range& e) {
49143       {
49144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49145       };
49146     } catch (std::exception& e) {
49147       {
49148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49149       };
49150     } catch (Dali::DaliException e) {
49151       {
49152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49153       };
49154     } catch (...) {
49155       {
49156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49157       };
49158     }
49159   }
49160
49161   jresult = (void *)result;
49162   return jresult;
49163 }
49164
49165
49166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49167   void * jresult ;
49168   std::string arg1 ;
49169   Dali::Property::Value arg2 ;
49170   Dali::Property::Value *argp2 ;
49171   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49172
49173   if (!jarg1) {
49174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49175     return 0;
49176   }
49177   (&arg1)->assign(jarg1);
49178   argp2 = (Dali::Property::Value *)jarg2;
49179   if (!argp2) {
49180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49181     return 0;
49182   }
49183   arg2 = *argp2;
49184   {
49185     try {
49186       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49187     } catch (std::out_of_range& e) {
49188       {
49189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49190       };
49191     } catch (std::exception& e) {
49192       {
49193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49194       };
49195     } catch (Dali::DaliException e) {
49196       {
49197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49198       };
49199     } catch (...) {
49200       {
49201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49202       };
49203     }
49204   }
49205
49206   jresult = (void *)result;
49207   return jresult;
49208 }
49209
49210
49211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49212   void * jresult ;
49213   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49214   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49215
49216   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49217   if (!arg1) {
49218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49219     return 0;
49220   }
49221   {
49222     try {
49223       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);
49224     } catch (std::out_of_range& e) {
49225       {
49226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49227       };
49228     } catch (std::exception& e) {
49229       {
49230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49231       };
49232     } catch (Dali::DaliException e) {
49233       {
49234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49235       };
49236     } catch (...) {
49237       {
49238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49239       };
49240     }
49241   }
49242
49243   jresult = (void *)result;
49244   return jresult;
49245 }
49246
49247
49248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49249   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49250   std::string *arg2 = 0 ;
49251
49252   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49253   if (!jarg2) {
49254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49255     return ;
49256   }
49257   std::string arg2_str(jarg2);
49258   arg2 = &arg2_str;
49259   if (arg1) (arg1)->first = *arg2;
49260
49261   //argout typemap for const std::string&
49262
49263 }
49264
49265
49266 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49267   char * jresult ;
49268   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49269   std::string *result = 0 ;
49270
49271   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49272   result = (std::string *) & ((arg1)->first);
49273   jresult = SWIG_csharp_string_callback(result->c_str());
49274   return jresult;
49275 }
49276
49277
49278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49279   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49280   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49281
49282   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49283   arg2 = (Dali::Property::Value *)jarg2;
49284   if (arg1) (arg1)->second = *arg2;
49285 }
49286
49287
49288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49289   void * jresult ;
49290   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49291   Dali::Property::Value *result = 0 ;
49292
49293   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49294   result = (Dali::Property::Value *)& ((arg1)->second);
49295   jresult = (void *)result;
49296   return jresult;
49297 }
49298
49299
49300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49301   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49302
49303   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49304   {
49305     try {
49306       delete arg1;
49307     } catch (std::out_of_range& e) {
49308       {
49309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49310       };
49311     } catch (std::exception& e) {
49312       {
49313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49314       };
49315     } catch (Dali::DaliException e) {
49316       {
49317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49318       };
49319     } catch (...) {
49320       {
49321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49322       };
49323     }
49324   }
49325
49326 }
49327
49328
49329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49330   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49331
49332   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49333   {
49334     try {
49335       (arg1)->clear();
49336     } catch (std::out_of_range& e) {
49337       {
49338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49339       };
49340     } catch (std::exception& e) {
49341       {
49342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49343       };
49344     } catch (Dali::DaliException e) {
49345       {
49346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49347       };
49348     } catch (...) {
49349       {
49350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49351       };
49352     }
49353   }
49354
49355 }
49356
49357
49358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49359   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49360   Dali::TouchPoint *arg2 = 0 ;
49361
49362   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49363   arg2 = (Dali::TouchPoint *)jarg2;
49364   if (!arg2) {
49365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49366     return ;
49367   }
49368   {
49369     try {
49370       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49371     } catch (std::out_of_range& e) {
49372       {
49373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49374       };
49375     } catch (std::exception& e) {
49376       {
49377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49378       };
49379     } catch (Dali::DaliException e) {
49380       {
49381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49382       };
49383     } catch (...) {
49384       {
49385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49386       };
49387     }
49388   }
49389
49390 }
49391
49392
49393 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49394   unsigned long jresult ;
49395   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49396   std::vector< Dali::TouchPoint >::size_type result;
49397
49398   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49399   {
49400     try {
49401       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49402     } catch (std::out_of_range& e) {
49403       {
49404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49405       };
49406     } catch (std::exception& e) {
49407       {
49408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49409       };
49410     } catch (Dali::DaliException e) {
49411       {
49412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49413       };
49414     } catch (...) {
49415       {
49416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49417       };
49418     }
49419   }
49420
49421   jresult = (unsigned long)result;
49422   return jresult;
49423 }
49424
49425
49426 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49427   unsigned long jresult ;
49428   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49429   std::vector< Dali::TouchPoint >::size_type result;
49430
49431   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49432   {
49433     try {
49434       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49435     } catch (std::out_of_range& e) {
49436       {
49437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49438       };
49439     } catch (std::exception& e) {
49440       {
49441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49442       };
49443     } catch (Dali::DaliException e) {
49444       {
49445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49446       };
49447     } catch (...) {
49448       {
49449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49450       };
49451     }
49452   }
49453
49454   jresult = (unsigned long)result;
49455   return jresult;
49456 }
49457
49458
49459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49460   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49461   std::vector< Dali::TouchPoint >::size_type arg2 ;
49462
49463   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49464   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49465   {
49466     try {
49467       (arg1)->reserve(arg2);
49468     } catch (std::out_of_range& e) {
49469       {
49470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49471       };
49472     } catch (std::exception& e) {
49473       {
49474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49475       };
49476     } catch (Dali::DaliException e) {
49477       {
49478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49479       };
49480     } catch (...) {
49481       {
49482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49483       };
49484     }
49485   }
49486
49487 }
49488
49489
49490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49491   void * jresult ;
49492   std::vector< Dali::TouchPoint > *result = 0 ;
49493
49494   {
49495     try {
49496       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49497     } catch (std::out_of_range& e) {
49498       {
49499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49500       };
49501     } catch (std::exception& e) {
49502       {
49503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49504       };
49505     } catch (Dali::DaliException e) {
49506       {
49507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49508       };
49509     } catch (...) {
49510       {
49511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49512       };
49513     }
49514   }
49515
49516   jresult = (void *)result;
49517   return jresult;
49518 }
49519
49520
49521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49522   void * jresult ;
49523   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49524   std::vector< Dali::TouchPoint > *result = 0 ;
49525
49526   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49527   if (!arg1) {
49528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49529     return 0;
49530   }
49531   {
49532     try {
49533       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49534     } catch (std::out_of_range& e) {
49535       {
49536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49537       };
49538     } catch (std::exception& e) {
49539       {
49540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49541       };
49542     } catch (Dali::DaliException e) {
49543       {
49544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49545       };
49546     } catch (...) {
49547       {
49548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49549       };
49550     }
49551   }
49552
49553   jresult = (void *)result;
49554   return jresult;
49555 }
49556
49557
49558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49559   void * jresult ;
49560   int arg1 ;
49561   std::vector< Dali::TouchPoint > *result = 0 ;
49562
49563   arg1 = (int)jarg1;
49564   {
49565     try {
49566       try {
49567         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49568       }
49569       catch(std::out_of_range &_e) {
49570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49571         return 0;
49572       }
49573
49574     } catch (std::out_of_range& e) {
49575       {
49576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49577       };
49578     } catch (std::exception& e) {
49579       {
49580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49581       };
49582     } catch (Dali::DaliException e) {
49583       {
49584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49585       };
49586     } catch (...) {
49587       {
49588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49589       };
49590     }
49591   }
49592
49593   jresult = (void *)result;
49594   return jresult;
49595 }
49596
49597
49598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49599   void * jresult ;
49600   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49601   int arg2 ;
49602   SwigValueWrapper< Dali::TouchPoint > result;
49603
49604   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49605   arg2 = (int)jarg2;
49606   {
49607     try {
49608       try {
49609         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49610       }
49611       catch(std::out_of_range &_e) {
49612         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49613         return 0;
49614       }
49615
49616     } catch (std::out_of_range& e) {
49617       {
49618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49619       };
49620     } catch (std::exception& e) {
49621       {
49622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49623       };
49624     } catch (Dali::DaliException e) {
49625       {
49626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49627       };
49628     } catch (...) {
49629       {
49630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49631       };
49632     }
49633   }
49634
49635   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49636   return jresult;
49637 }
49638
49639
49640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49641   void * jresult ;
49642   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49643   int arg2 ;
49644   Dali::TouchPoint *result = 0 ;
49645
49646   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49647   arg2 = (int)jarg2;
49648   {
49649     try {
49650       try {
49651         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49652       }
49653       catch(std::out_of_range &_e) {
49654         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49655         return 0;
49656       }
49657
49658     } catch (std::out_of_range& e) {
49659       {
49660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49661       };
49662     } catch (std::exception& e) {
49663       {
49664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49665       };
49666     } catch (Dali::DaliException e) {
49667       {
49668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49669       };
49670     } catch (...) {
49671       {
49672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49673       };
49674     }
49675   }
49676
49677   jresult = (void *)result;
49678   return jresult;
49679 }
49680
49681
49682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49683   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49684   int arg2 ;
49685   Dali::TouchPoint *arg3 = 0 ;
49686
49687   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49688   arg2 = (int)jarg2;
49689   arg3 = (Dali::TouchPoint *)jarg3;
49690   if (!arg3) {
49691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49692     return ;
49693   }
49694   {
49695     try {
49696       try {
49697         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49698       }
49699       catch(std::out_of_range &_e) {
49700         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49701         return ;
49702       }
49703
49704     } catch (std::out_of_range& e) {
49705       {
49706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49707       };
49708     } catch (std::exception& e) {
49709       {
49710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49711       };
49712     } catch (Dali::DaliException e) {
49713       {
49714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49715       };
49716     } catch (...) {
49717       {
49718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49719       };
49720     }
49721   }
49722
49723 }
49724
49725
49726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49727   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49728   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49729
49730   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49731   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49732   if (!arg2) {
49733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49734     return ;
49735   }
49736   {
49737     try {
49738       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49739     } catch (std::out_of_range& e) {
49740       {
49741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49742       };
49743     } catch (std::exception& e) {
49744       {
49745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49746       };
49747     } catch (Dali::DaliException e) {
49748       {
49749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49750       };
49751     } catch (...) {
49752       {
49753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49754       };
49755     }
49756   }
49757
49758 }
49759
49760
49761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49762   void * jresult ;
49763   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49764   int arg2 ;
49765   int arg3 ;
49766   std::vector< Dali::TouchPoint > *result = 0 ;
49767
49768   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49769   arg2 = (int)jarg2;
49770   arg3 = (int)jarg3;
49771   {
49772     try {
49773       try {
49774         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49775       }
49776       catch(std::out_of_range &_e) {
49777         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49778         return 0;
49779       }
49780       catch(std::invalid_argument &_e) {
49781         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49782         return 0;
49783       }
49784
49785     } catch (std::out_of_range& e) {
49786       {
49787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49788       };
49789     } catch (std::exception& e) {
49790       {
49791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49792       };
49793     } catch (Dali::DaliException e) {
49794       {
49795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49796       };
49797     } catch (...) {
49798       {
49799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49800       };
49801     }
49802   }
49803
49804   jresult = (void *)result;
49805   return jresult;
49806 }
49807
49808
49809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49810   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49811   int arg2 ;
49812   Dali::TouchPoint *arg3 = 0 ;
49813
49814   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49815   arg2 = (int)jarg2;
49816   arg3 = (Dali::TouchPoint *)jarg3;
49817   if (!arg3) {
49818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49819     return ;
49820   }
49821   {
49822     try {
49823       try {
49824         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49825       }
49826       catch(std::out_of_range &_e) {
49827         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49828         return ;
49829       }
49830
49831     } catch (std::out_of_range& e) {
49832       {
49833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49834       };
49835     } catch (std::exception& e) {
49836       {
49837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49838       };
49839     } catch (Dali::DaliException e) {
49840       {
49841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49842       };
49843     } catch (...) {
49844       {
49845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49846       };
49847     }
49848   }
49849
49850 }
49851
49852
49853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49854   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49855   int arg2 ;
49856   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49857
49858   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49859   arg2 = (int)jarg2;
49860   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49861   if (!arg3) {
49862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49863     return ;
49864   }
49865   {
49866     try {
49867       try {
49868         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49869       }
49870       catch(std::out_of_range &_e) {
49871         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49872         return ;
49873       }
49874
49875     } catch (std::out_of_range& e) {
49876       {
49877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49878       };
49879     } catch (std::exception& e) {
49880       {
49881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49882       };
49883     } catch (Dali::DaliException e) {
49884       {
49885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49886       };
49887     } catch (...) {
49888       {
49889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49890       };
49891     }
49892   }
49893
49894 }
49895
49896
49897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49898   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49899   int arg2 ;
49900
49901   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49902   arg2 = (int)jarg2;
49903   {
49904     try {
49905       try {
49906         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49907       }
49908       catch(std::out_of_range &_e) {
49909         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49910         return ;
49911       }
49912
49913     } catch (std::out_of_range& e) {
49914       {
49915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49916       };
49917     } catch (std::exception& e) {
49918       {
49919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49920       };
49921     } catch (Dali::DaliException e) {
49922       {
49923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49924       };
49925     } catch (...) {
49926       {
49927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49928       };
49929     }
49930   }
49931
49932 }
49933
49934
49935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49936   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49937   int arg2 ;
49938   int arg3 ;
49939
49940   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49941   arg2 = (int)jarg2;
49942   arg3 = (int)jarg3;
49943   {
49944     try {
49945       try {
49946         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49947       }
49948       catch(std::out_of_range &_e) {
49949         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49950         return ;
49951       }
49952       catch(std::invalid_argument &_e) {
49953         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49954         return ;
49955       }
49956
49957     } catch (std::out_of_range& e) {
49958       {
49959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49960       };
49961     } catch (std::exception& e) {
49962       {
49963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49964       };
49965     } catch (Dali::DaliException e) {
49966       {
49967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49968       };
49969     } catch (...) {
49970       {
49971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49972       };
49973     }
49974   }
49975
49976 }
49977
49978
49979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49980   void * jresult ;
49981   Dali::TouchPoint *arg1 = 0 ;
49982   int arg2 ;
49983   std::vector< Dali::TouchPoint > *result = 0 ;
49984
49985   arg1 = (Dali::TouchPoint *)jarg1;
49986   if (!arg1) {
49987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49988     return 0;
49989   }
49990   arg2 = (int)jarg2;
49991   {
49992     try {
49993       try {
49994         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49995       }
49996       catch(std::out_of_range &_e) {
49997         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49998         return 0;
49999       }
50000
50001     } catch (std::out_of_range& e) {
50002       {
50003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50004       };
50005     } catch (std::exception& e) {
50006       {
50007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50008       };
50009     } catch (Dali::DaliException e) {
50010       {
50011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50012       };
50013     } catch (...) {
50014       {
50015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50016       };
50017     }
50018   }
50019
50020   jresult = (void *)result;
50021   return jresult;
50022 }
50023
50024
50025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
50026   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50027
50028   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50029   {
50030     try {
50031       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
50032     } catch (std::out_of_range& e) {
50033       {
50034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50035       };
50036     } catch (std::exception& e) {
50037       {
50038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50039       };
50040     } catch (Dali::DaliException e) {
50041       {
50042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50043       };
50044     } catch (...) {
50045       {
50046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50047       };
50048     }
50049   }
50050
50051 }
50052
50053
50054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
50055   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50056   int arg2 ;
50057   int arg3 ;
50058
50059   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50060   arg2 = (int)jarg2;
50061   arg3 = (int)jarg3;
50062   {
50063     try {
50064       try {
50065         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
50066       }
50067       catch(std::out_of_range &_e) {
50068         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50069         return ;
50070       }
50071       catch(std::invalid_argument &_e) {
50072         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
50073         return ;
50074       }
50075
50076     } catch (std::out_of_range& e) {
50077       {
50078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50079       };
50080     } catch (std::exception& e) {
50081       {
50082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50083       };
50084     } catch (Dali::DaliException e) {
50085       {
50086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50087       };
50088     } catch (...) {
50089       {
50090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50091       };
50092     }
50093   }
50094
50095 }
50096
50097
50098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
50099   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50100   int arg2 ;
50101   std::vector< Dali::TouchPoint > *arg3 = 0 ;
50102
50103   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50104   arg2 = (int)jarg2;
50105   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
50106   if (!arg3) {
50107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
50108     return ;
50109   }
50110   {
50111     try {
50112       try {
50113         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
50114       }
50115       catch(std::out_of_range &_e) {
50116         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50117         return ;
50118       }
50119
50120     } catch (std::out_of_range& e) {
50121       {
50122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50123       };
50124     } catch (std::exception& e) {
50125       {
50126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50127       };
50128     } catch (Dali::DaliException e) {
50129       {
50130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50131       };
50132     } catch (...) {
50133       {
50134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50135       };
50136     }
50137   }
50138
50139 }
50140
50141
50142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50143   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50144
50145   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50146   {
50147     try {
50148       delete arg1;
50149     } catch (std::out_of_range& e) {
50150       {
50151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50152       };
50153     } catch (std::exception& e) {
50154       {
50155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50156       };
50157     } catch (Dali::DaliException e) {
50158       {
50159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50160       };
50161     } catch (...) {
50162       {
50163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50164       };
50165     }
50166   }
50167
50168 }
50169
50170
50171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50172   void * jresult ;
50173   Dali::Rect< int > *result = 0 ;
50174
50175   {
50176     try {
50177       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50178     } catch (std::out_of_range& e) {
50179       {
50180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50181       };
50182     } catch (std::exception& e) {
50183       {
50184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50185       };
50186     } catch (Dali::DaliException e) {
50187       {
50188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50189       };
50190     } catch (...) {
50191       {
50192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50193       };
50194     }
50195   }
50196
50197   jresult = (void *)result;
50198   return jresult;
50199 }
50200
50201
50202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50203   void * jresult ;
50204   int arg1 ;
50205   int arg2 ;
50206   int arg3 ;
50207   int arg4 ;
50208   Dali::Rect< int > *result = 0 ;
50209
50210   arg1 = (int)jarg1;
50211   arg2 = (int)jarg2;
50212   arg3 = (int)jarg3;
50213   arg4 = (int)jarg4;
50214   {
50215     try {
50216       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50217     } catch (std::out_of_range& e) {
50218       {
50219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50220       };
50221     } catch (std::exception& e) {
50222       {
50223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50224       };
50225     } catch (Dali::DaliException e) {
50226       {
50227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50228       };
50229     } catch (...) {
50230       {
50231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50232       };
50233     }
50234   }
50235
50236   jresult = (void *)result;
50237   return jresult;
50238 }
50239
50240
50241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50242   void * jresult ;
50243   Dali::Rect< int > *arg1 = 0 ;
50244   Dali::Rect< int > *result = 0 ;
50245
50246   arg1 = (Dali::Rect< int > *)jarg1;
50247   if (!arg1) {
50248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50249     return 0;
50250   }
50251   {
50252     try {
50253       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50254     } catch (std::out_of_range& e) {
50255       {
50256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50257       };
50258     } catch (std::exception& e) {
50259       {
50260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50261       };
50262     } catch (Dali::DaliException e) {
50263       {
50264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50265       };
50266     } catch (...) {
50267       {
50268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50269       };
50270     }
50271   }
50272
50273   jresult = (void *)result;
50274   return jresult;
50275 }
50276
50277
50278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50279   void * jresult ;
50280   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50281   Dali::Rect< int > *arg2 = 0 ;
50282   Dali::Rect< int > *result = 0 ;
50283
50284   arg1 = (Dali::Rect< int > *)jarg1;
50285   arg2 = (Dali::Rect< int > *)jarg2;
50286   if (!arg2) {
50287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50288     return 0;
50289   }
50290   {
50291     try {
50292       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50293     } catch (std::out_of_range& e) {
50294       {
50295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50296       };
50297     } catch (std::exception& e) {
50298       {
50299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50300       };
50301     } catch (Dali::DaliException e) {
50302       {
50303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50304       };
50305     } catch (...) {
50306       {
50307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50308       };
50309     }
50310   }
50311
50312   jresult = (void *)result;
50313   return jresult;
50314 }
50315
50316
50317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50318   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50319   int arg2 ;
50320   int arg3 ;
50321   int arg4 ;
50322   int arg5 ;
50323
50324   arg1 = (Dali::Rect< int > *)jarg1;
50325   arg2 = (int)jarg2;
50326   arg3 = (int)jarg3;
50327   arg4 = (int)jarg4;
50328   arg5 = (int)jarg5;
50329   {
50330     try {
50331       (arg1)->Set(arg2,arg3,arg4,arg5);
50332     } catch (std::out_of_range& e) {
50333       {
50334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50335       };
50336     } catch (std::exception& e) {
50337       {
50338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50339       };
50340     } catch (Dali::DaliException e) {
50341       {
50342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50343       };
50344     } catch (...) {
50345       {
50346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50347       };
50348     }
50349   }
50350
50351 }
50352
50353
50354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50355   unsigned int jresult ;
50356   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50357   bool result;
50358
50359   arg1 = (Dali::Rect< int > *)jarg1;
50360   {
50361     try {
50362       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50363     } catch (std::out_of_range& e) {
50364       {
50365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50366       };
50367     } catch (std::exception& e) {
50368       {
50369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (Dali::DaliException e) {
50372       {
50373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50374       };
50375     } catch (...) {
50376       {
50377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50378       };
50379     }
50380   }
50381
50382   jresult = result;
50383   return jresult;
50384 }
50385
50386
50387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50388   int jresult ;
50389   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50390   int result;
50391
50392   arg1 = (Dali::Rect< int > *)jarg1;
50393   {
50394     try {
50395       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50396     } catch (std::out_of_range& e) {
50397       {
50398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50399       };
50400     } catch (std::exception& e) {
50401       {
50402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50403       };
50404     } catch (Dali::DaliException e) {
50405       {
50406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50407       };
50408     } catch (...) {
50409       {
50410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50411       };
50412     }
50413   }
50414
50415   jresult = result;
50416   return jresult;
50417 }
50418
50419
50420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50421   int jresult ;
50422   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50423   int result;
50424
50425   arg1 = (Dali::Rect< int > *)jarg1;
50426   {
50427     try {
50428       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50429     } catch (std::out_of_range& e) {
50430       {
50431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50432       };
50433     } catch (std::exception& e) {
50434       {
50435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50436       };
50437     } catch (Dali::DaliException e) {
50438       {
50439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50440       };
50441     } catch (...) {
50442       {
50443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50444       };
50445     }
50446   }
50447
50448   jresult = result;
50449   return jresult;
50450 }
50451
50452
50453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50454   int jresult ;
50455   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50456   int result;
50457
50458   arg1 = (Dali::Rect< int > *)jarg1;
50459   {
50460     try {
50461       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50462     } catch (std::out_of_range& e) {
50463       {
50464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50465       };
50466     } catch (std::exception& e) {
50467       {
50468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50469       };
50470     } catch (Dali::DaliException e) {
50471       {
50472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50473       };
50474     } catch (...) {
50475       {
50476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50477       };
50478     }
50479   }
50480
50481   jresult = result;
50482   return jresult;
50483 }
50484
50485
50486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50487   int jresult ;
50488   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50489   int result;
50490
50491   arg1 = (Dali::Rect< int > *)jarg1;
50492   {
50493     try {
50494       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50495     } catch (std::out_of_range& e) {
50496       {
50497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50498       };
50499     } catch (std::exception& e) {
50500       {
50501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50502       };
50503     } catch (Dali::DaliException e) {
50504       {
50505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50506       };
50507     } catch (...) {
50508       {
50509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50510       };
50511     }
50512   }
50513
50514   jresult = result;
50515   return jresult;
50516 }
50517
50518
50519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50520   int jresult ;
50521   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50522   int result;
50523
50524   arg1 = (Dali::Rect< int > *)jarg1;
50525   {
50526     try {
50527       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50528     } catch (std::out_of_range& e) {
50529       {
50530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50531       };
50532     } catch (std::exception& e) {
50533       {
50534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50535       };
50536     } catch (Dali::DaliException e) {
50537       {
50538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50539       };
50540     } catch (...) {
50541       {
50542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50543       };
50544     }
50545   }
50546
50547   jresult = result;
50548   return jresult;
50549 }
50550
50551
50552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50553   unsigned int jresult ;
50554   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50555   Dali::Rect< int > *arg2 = 0 ;
50556   bool result;
50557
50558   arg1 = (Dali::Rect< int > *)jarg1;
50559   arg2 = (Dali::Rect< int > *)jarg2;
50560   if (!arg2) {
50561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50562     return 0;
50563   }
50564   {
50565     try {
50566       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50567     } catch (std::out_of_range& e) {
50568       {
50569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50570       };
50571     } catch (std::exception& e) {
50572       {
50573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50574       };
50575     } catch (Dali::DaliException e) {
50576       {
50577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50578       };
50579     } catch (...) {
50580       {
50581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50582       };
50583     }
50584   }
50585
50586   jresult = result;
50587   return jresult;
50588 }
50589
50590
50591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50592   unsigned int jresult ;
50593   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50594   Dali::Rect< int > *arg2 = 0 ;
50595   bool result;
50596
50597   arg1 = (Dali::Rect< int > *)jarg1;
50598   arg2 = (Dali::Rect< int > *)jarg2;
50599   if (!arg2) {
50600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50601     return 0;
50602   }
50603   {
50604     try {
50605       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50606     } catch (std::out_of_range& e) {
50607       {
50608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50609       };
50610     } catch (std::exception& e) {
50611       {
50612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50613       };
50614     } catch (Dali::DaliException e) {
50615       {
50616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50617       };
50618     } catch (...) {
50619       {
50620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50621       };
50622     }
50623   }
50624
50625   jresult = result;
50626   return jresult;
50627 }
50628
50629
50630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50631   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50632   int arg2 ;
50633
50634   arg1 = (Dali::Rect< int > *)jarg1;
50635   arg2 = (int)jarg2;
50636   if (arg1) (arg1)->x = arg2;
50637 }
50638
50639
50640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50641   int jresult ;
50642   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50643   int result;
50644
50645   arg1 = (Dali::Rect< int > *)jarg1;
50646   result = (int) ((arg1)->x);
50647   jresult = result;
50648   return jresult;
50649 }
50650
50651
50652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50653   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50654   int arg2 ;
50655
50656   arg1 = (Dali::Rect< int > *)jarg1;
50657   arg2 = (int)jarg2;
50658   if (arg1) (arg1)->left = arg2;
50659 }
50660
50661
50662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50663   int jresult ;
50664   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50665   int result;
50666
50667   arg1 = (Dali::Rect< int > *)jarg1;
50668   result = (int) ((arg1)->left);
50669   jresult = result;
50670   return jresult;
50671 }
50672
50673
50674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50675   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50676   int arg2 ;
50677
50678   arg1 = (Dali::Rect< int > *)jarg1;
50679   arg2 = (int)jarg2;
50680   if (arg1) (arg1)->y = arg2;
50681 }
50682
50683
50684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50685   int jresult ;
50686   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50687   int result;
50688
50689   arg1 = (Dali::Rect< int > *)jarg1;
50690   result = (int) ((arg1)->y);
50691   jresult = result;
50692   return jresult;
50693 }
50694
50695
50696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50697   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50698   int arg2 ;
50699
50700   arg1 = (Dali::Rect< int > *)jarg1;
50701   arg2 = (int)jarg2;
50702   if (arg1) (arg1)->right = arg2;
50703 }
50704
50705
50706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50707   int jresult ;
50708   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50709   int result;
50710
50711   arg1 = (Dali::Rect< int > *)jarg1;
50712   result = (int) ((arg1)->right);
50713   jresult = result;
50714   return jresult;
50715 }
50716
50717
50718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50719   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50720   int arg2 ;
50721
50722   arg1 = (Dali::Rect< int > *)jarg1;
50723   arg2 = (int)jarg2;
50724   if (arg1) (arg1)->width = arg2;
50725 }
50726
50727
50728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50729   int jresult ;
50730   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50731   int result;
50732
50733   arg1 = (Dali::Rect< int > *)jarg1;
50734   result = (int) ((arg1)->width);
50735   jresult = result;
50736   return jresult;
50737 }
50738
50739
50740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50741   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50742   int arg2 ;
50743
50744   arg1 = (Dali::Rect< int > *)jarg1;
50745   arg2 = (int)jarg2;
50746   if (arg1) (arg1)->bottom = arg2;
50747 }
50748
50749
50750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50751   int jresult ;
50752   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50753   int result;
50754
50755   arg1 = (Dali::Rect< int > *)jarg1;
50756   result = (int) ((arg1)->bottom);
50757   jresult = result;
50758   return jresult;
50759 }
50760
50761
50762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50763   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50764   int arg2 ;
50765
50766   arg1 = (Dali::Rect< int > *)jarg1;
50767   arg2 = (int)jarg2;
50768   if (arg1) (arg1)->height = arg2;
50769 }
50770
50771
50772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50773   int jresult ;
50774   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50775   int result;
50776
50777   arg1 = (Dali::Rect< int > *)jarg1;
50778   result = (int) ((arg1)->height);
50779   jresult = result;
50780   return jresult;
50781 }
50782
50783
50784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50785   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50786   int arg2 ;
50787
50788   arg1 = (Dali::Rect< int > *)jarg1;
50789   arg2 = (int)jarg2;
50790   if (arg1) (arg1)->top = arg2;
50791 }
50792
50793
50794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50795   int jresult ;
50796   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50797   int result;
50798
50799   arg1 = (Dali::Rect< int > *)jarg1;
50800   result = (int) ((arg1)->top);
50801   jresult = result;
50802   return jresult;
50803 }
50804
50805
50806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50807   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50808
50809   arg1 = (Dali::Rect< int > *)jarg1;
50810   {
50811     try {
50812       delete arg1;
50813     } catch (std::out_of_range& e) {
50814       {
50815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50816       };
50817     } catch (std::exception& e) {
50818       {
50819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50820       };
50821     } catch (Dali::DaliException e) {
50822       {
50823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50824       };
50825     } catch (...) {
50826       {
50827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50828       };
50829     }
50830   }
50831
50832 }
50833
50834
50835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50836   void * jresult ;
50837   Dali::Rect< float > *result = 0 ;
50838
50839   {
50840     try {
50841       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50842     } catch (std::out_of_range& e) {
50843       {
50844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50845       };
50846     } catch (std::exception& e) {
50847       {
50848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50849       };
50850     } catch (Dali::DaliException e) {
50851       {
50852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50853       };
50854     } catch (...) {
50855       {
50856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50857       };
50858     }
50859   }
50860
50861   jresult = (void *)result;
50862   return jresult;
50863 }
50864
50865
50866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50867   void * jresult ;
50868   float arg1 ;
50869   float arg2 ;
50870   float arg3 ;
50871   float arg4 ;
50872   Dali::Rect< float > *result = 0 ;
50873
50874   arg1 = (float)jarg1;
50875   arg2 = (float)jarg2;
50876   arg3 = (float)jarg4;
50877   arg4 = (float)jarg3;
50878   {
50879     try {
50880       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50881     } catch (std::out_of_range& e) {
50882       {
50883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50884       };
50885     } catch (std::exception& e) {
50886       {
50887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50888       };
50889     } catch (Dali::DaliException e) {
50890       {
50891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50892       };
50893     } catch (...) {
50894       {
50895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50896       };
50897     }
50898   }
50899
50900   jresult = (void *)result;
50901   return jresult;
50902 }
50903
50904
50905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50906   void * jresult ;
50907   Dali::Rect< float > *arg1 = 0 ;
50908   Dali::Rect< float > *result = 0 ;
50909
50910   arg1 = (Dali::Rect< float > *)jarg1;
50911   if (!arg1) {
50912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50913     return 0;
50914   }
50915   {
50916     try {
50917       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50918     } catch (std::out_of_range& e) {
50919       {
50920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50921       };
50922     } catch (std::exception& e) {
50923       {
50924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50925       };
50926     } catch (Dali::DaliException e) {
50927       {
50928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50929       };
50930     } catch (...) {
50931       {
50932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50933       };
50934     }
50935   }
50936
50937   jresult = (void *)result;
50938   return jresult;
50939 }
50940
50941
50942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50943   void * jresult ;
50944   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50945   Dali::Rect< float > *arg2 = 0 ;
50946   Dali::Rect< float > *result = 0 ;
50947
50948   arg1 = (Dali::Rect< float > *)jarg1;
50949   arg2 = (Dali::Rect< float > *)jarg2;
50950   if (!arg2) {
50951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50952     return 0;
50953   }
50954   {
50955     try {
50956       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50957     } catch (std::out_of_range& e) {
50958       {
50959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50960       };
50961     } catch (std::exception& e) {
50962       {
50963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50964       };
50965     } catch (Dali::DaliException e) {
50966       {
50967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50968       };
50969     } catch (...) {
50970       {
50971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50972       };
50973     }
50974   }
50975
50976   jresult = (void *)result;
50977   return jresult;
50978 }
50979
50980
50981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50982   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50983   float arg2 ;
50984   float arg3 ;
50985   float arg4 ;
50986   float arg5 ;
50987
50988   arg1 = (Dali::Rect< float > *)jarg1;
50989   arg2 = (float)jarg2;
50990   arg3 = (float)jarg3;
50991   arg4 = (float)jarg5;
50992   arg5 = (float)jarg4;
50993   {
50994     try {
50995       (arg1)->Set(arg2,arg3,arg4,arg5);
50996     } catch (std::out_of_range& e) {
50997       {
50998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50999       };
51000     } catch (std::exception& e) {
51001       {
51002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51003       };
51004     } catch (Dali::DaliException e) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51007       };
51008     } catch (...) {
51009       {
51010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51011       };
51012     }
51013   }
51014
51015 }
51016
51017
51018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
51019   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51020   float arg2 ;
51021
51022   arg1 = (Dali::Rect< float > *)jarg1;
51023   arg2 = (float)jarg2;
51024   if (arg1) (arg1)->left = arg2;
51025 }
51026
51027
51028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
51029   float jresult ;
51030   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51031   float result;
51032
51033   arg1 = (Dali::Rect< float > *)jarg1;
51034   result = (float) ((arg1)->left);
51035   jresult = result;
51036   return jresult;
51037 }
51038
51039
51040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
51041   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51042   float arg2 ;
51043
51044   arg1 = (Dali::Rect< float > *)jarg1;
51045   arg2 = (float)jarg2;
51046   if (arg1) (arg1)->left = arg2;
51047 }
51048
51049
51050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
51051   float jresult ;
51052   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51053   float result;
51054
51055   arg1 = (Dali::Rect< float > *)jarg1;
51056   result = (float) ((arg1)->left);
51057   jresult = result;
51058   return jresult;
51059 }
51060
51061
51062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
51063   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51064   float arg2 ;
51065
51066   arg1 = (Dali::Rect< float > *)jarg1;
51067   arg2 = (float)jarg2;
51068   if (arg1) (arg1)->right = arg2;
51069 }
51070
51071
51072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
51073   float jresult ;
51074   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51075   float result;
51076
51077   arg1 = (Dali::Rect< float > *)jarg1;
51078   result = (float) ((arg1)->right);
51079   jresult = result;
51080   return jresult;
51081 }
51082
51083
51084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
51085   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51086   float arg2 ;
51087
51088   arg1 = (Dali::Rect< float > *)jarg1;
51089   arg2 = (float)jarg2;
51090   if (arg1) (arg1)->right = arg2;
51091 }
51092
51093
51094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
51095   float jresult ;
51096   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51097   float result;
51098
51099   arg1 = (Dali::Rect< float > *)jarg1;
51100   result = (float) ((arg1)->right);
51101   jresult = result;
51102   return jresult;
51103 }
51104
51105
51106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
51107   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51108   float arg2 ;
51109
51110   arg1 = (Dali::Rect< float > *)jarg1;
51111   arg2 = (float)jarg2;
51112   if (arg1) (arg1)->bottom = arg2;
51113 }
51114
51115
51116 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51117   float jresult ;
51118   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51119   float result;
51120
51121   arg1 = (Dali::Rect< float > *)jarg1;
51122   result = (float) ((arg1)->bottom);
51123   jresult = result;
51124   return jresult;
51125 }
51126
51127
51128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51129   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51130   float arg2 ;
51131
51132   arg1 = (Dali::Rect< float > *)jarg1;
51133   arg2 = (float)jarg2;
51134   if (arg1) (arg1)->top = arg2;
51135 }
51136
51137
51138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51139   float jresult ;
51140   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51141   float result;
51142
51143   arg1 = (Dali::Rect< float > *)jarg1;
51144   result = (float) ((arg1)->top);
51145   jresult = result;
51146   return jresult;
51147 }
51148
51149
51150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51151   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51152
51153   arg1 = (Dali::Rect< float > *)jarg1;
51154   {
51155     try {
51156       delete arg1;
51157     } catch (std::out_of_range& e) {
51158       {
51159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51160       };
51161     } catch (std::exception& e) {
51162       {
51163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51164       };
51165     } catch (Dali::DaliException e) {
51166       {
51167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51168       };
51169     } catch (...) {
51170       {
51171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51172       };
51173     }
51174   }
51175
51176 }
51177
51178
51179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51180   int jresult ;
51181   int result;
51182
51183   result = (int)Dali::Vector< int >::BaseType;
51184   jresult = (int)result;
51185   return jresult;
51186 }
51187
51188
51189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51190   void * jresult ;
51191   Dali::Vector< int > *result = 0 ;
51192
51193   {
51194     try {
51195       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51196     } catch (std::out_of_range& e) {
51197       {
51198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51199       };
51200     } catch (std::exception& e) {
51201       {
51202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51203       };
51204     } catch (Dali::DaliException e) {
51205       {
51206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51207       };
51208     } catch (...) {
51209       {
51210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51211       };
51212     }
51213   }
51214
51215   jresult = (void *)result;
51216   return jresult;
51217 }
51218
51219
51220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51221   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51222
51223   arg1 = (Dali::Vector< int > *)jarg1;
51224   {
51225     try {
51226       delete arg1;
51227     } catch (std::out_of_range& e) {
51228       {
51229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51230       };
51231     } catch (std::exception& e) {
51232       {
51233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51234       };
51235     } catch (Dali::DaliException e) {
51236       {
51237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51238       };
51239     } catch (...) {
51240       {
51241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51242       };
51243     }
51244   }
51245
51246 }
51247
51248
51249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51250   void * jresult ;
51251   Dali::Vector< int > *arg1 = 0 ;
51252   Dali::Vector< int > *result = 0 ;
51253
51254   arg1 = (Dali::Vector< int > *)jarg1;
51255   if (!arg1) {
51256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51257     return 0;
51258   }
51259   {
51260     try {
51261       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51262     } catch (std::out_of_range& e) {
51263       {
51264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51265       };
51266     } catch (std::exception& e) {
51267       {
51268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51269       };
51270     } catch (Dali::DaliException e) {
51271       {
51272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51273       };
51274     } catch (...) {
51275       {
51276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51277       };
51278     }
51279   }
51280
51281   jresult = (void *)result;
51282   return jresult;
51283 }
51284
51285
51286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51287   void * jresult ;
51288   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51289   Dali::Vector< int > *arg2 = 0 ;
51290   Dali::Vector< int > *result = 0 ;
51291
51292   arg1 = (Dali::Vector< int > *)jarg1;
51293   arg2 = (Dali::Vector< int > *)jarg2;
51294   if (!arg2) {
51295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51296     return 0;
51297   }
51298   {
51299     try {
51300       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51301     } catch (std::out_of_range& e) {
51302       {
51303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51304       };
51305     } catch (std::exception& e) {
51306       {
51307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51308       };
51309     } catch (Dali::DaliException e) {
51310       {
51311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51312       };
51313     } catch (...) {
51314       {
51315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51316       };
51317     }
51318   }
51319
51320   jresult = (void *)result;
51321   return jresult;
51322 }
51323
51324
51325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51326   void * jresult ;
51327   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51328   Dali::Vector< int >::Iterator result;
51329
51330   arg1 = (Dali::Vector< int > *)jarg1;
51331   {
51332     try {
51333       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51334     } catch (std::out_of_range& e) {
51335       {
51336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51337       };
51338     } catch (std::exception& e) {
51339       {
51340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51341       };
51342     } catch (Dali::DaliException e) {
51343       {
51344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51345       };
51346     } catch (...) {
51347       {
51348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51349       };
51350     }
51351   }
51352
51353   jresult = (void *)result;
51354   return jresult;
51355 }
51356
51357
51358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51359   void * jresult ;
51360   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51361   Dali::Vector< int >::Iterator result;
51362
51363   arg1 = (Dali::Vector< int > *)jarg1;
51364   {
51365     try {
51366       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51367     } catch (std::out_of_range& e) {
51368       {
51369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51370       };
51371     } catch (std::exception& e) {
51372       {
51373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51374       };
51375     } catch (Dali::DaliException e) {
51376       {
51377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51378       };
51379     } catch (...) {
51380       {
51381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51382       };
51383     }
51384   }
51385
51386   jresult = (void *)result;
51387   return jresult;
51388 }
51389
51390
51391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51392   void * jresult ;
51393   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51394   Dali::Vector< int >::SizeType arg2 ;
51395   Dali::Vector< int >::ItemType *result = 0 ;
51396
51397   arg1 = (Dali::Vector< int > *)jarg1;
51398   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51399   {
51400     try {
51401       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51402     } catch (std::out_of_range& e) {
51403       {
51404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51405       };
51406     } catch (std::exception& e) {
51407       {
51408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51409       };
51410     } catch (Dali::DaliException e) {
51411       {
51412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51413       };
51414     } catch (...) {
51415       {
51416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51417       };
51418     }
51419   }
51420
51421   jresult = (void *)result;
51422   return jresult;
51423 }
51424
51425
51426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51427   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51428   Dali::Vector< int >::ItemType *arg2 = 0 ;
51429   Dali::Vector< int >::ItemType temp2 ;
51430
51431   arg1 = (Dali::Vector< int > *)jarg1;
51432   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51433   arg2 = &temp2;
51434   {
51435     try {
51436       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51437     } catch (std::out_of_range& e) {
51438       {
51439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51440       };
51441     } catch (std::exception& e) {
51442       {
51443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51444       };
51445     } catch (Dali::DaliException e) {
51446       {
51447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51448       };
51449     } catch (...) {
51450       {
51451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51452       };
51453     }
51454   }
51455
51456 }
51457
51458
51459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51460   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51461   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51462   Dali::Vector< int >::ItemType *arg3 = 0 ;
51463   Dali::Vector< int >::ItemType temp3 ;
51464
51465   arg1 = (Dali::Vector< int > *)jarg1;
51466   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51467   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51468   arg3 = &temp3;
51469   {
51470     try {
51471       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51472     } catch (std::out_of_range& e) {
51473       {
51474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51475       };
51476     } catch (std::exception& e) {
51477       {
51478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51479       };
51480     } catch (Dali::DaliException e) {
51481       {
51482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51483       };
51484     } catch (...) {
51485       {
51486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51487       };
51488     }
51489   }
51490
51491 }
51492
51493
51494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51495   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51496   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51497   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51498   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51499
51500   arg1 = (Dali::Vector< int > *)jarg1;
51501   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51502   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51503   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51504   {
51505     try {
51506       (arg1)->Insert(arg2,arg3,arg4);
51507     } catch (std::out_of_range& e) {
51508       {
51509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51510       };
51511     } catch (std::exception& e) {
51512       {
51513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51514       };
51515     } catch (Dali::DaliException e) {
51516       {
51517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51518       };
51519     } catch (...) {
51520       {
51521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51522       };
51523     }
51524   }
51525
51526 }
51527
51528
51529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51530   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51531   Dali::Vector< int >::SizeType arg2 ;
51532
51533   arg1 = (Dali::Vector< int > *)jarg1;
51534   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51535   {
51536     try {
51537       (arg1)->Reserve(arg2);
51538     } catch (std::out_of_range& e) {
51539       {
51540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51541       };
51542     } catch (std::exception& e) {
51543       {
51544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51545       };
51546     } catch (Dali::DaliException e) {
51547       {
51548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51549       };
51550     } catch (...) {
51551       {
51552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51553       };
51554     }
51555   }
51556
51557 }
51558
51559
51560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51561   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51562   Dali::Vector< int >::SizeType arg2 ;
51563
51564   arg1 = (Dali::Vector< int > *)jarg1;
51565   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51566   {
51567     try {
51568       (arg1)->Resize(arg2);
51569     } catch (std::out_of_range& e) {
51570       {
51571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51572       };
51573     } catch (std::exception& e) {
51574       {
51575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51576       };
51577     } catch (Dali::DaliException e) {
51578       {
51579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51580       };
51581     } catch (...) {
51582       {
51583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51584       };
51585     }
51586   }
51587
51588 }
51589
51590
51591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51592   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51593   Dali::Vector< int >::SizeType arg2 ;
51594   Dali::Vector< int >::ItemType *arg3 = 0 ;
51595   Dali::Vector< int >::ItemType temp3 ;
51596
51597   arg1 = (Dali::Vector< int > *)jarg1;
51598   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51599   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51600   arg3 = &temp3;
51601   {
51602     try {
51603       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51604     } catch (std::out_of_range& e) {
51605       {
51606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51607       };
51608     } catch (std::exception& e) {
51609       {
51610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51611       };
51612     } catch (Dali::DaliException e) {
51613       {
51614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51615       };
51616     } catch (...) {
51617       {
51618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51619       };
51620     }
51621   }
51622
51623 }
51624
51625
51626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51627   void * jresult ;
51628   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51629   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51630   Dali::Vector< int >::Iterator result;
51631
51632   arg1 = (Dali::Vector< int > *)jarg1;
51633   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51634   {
51635     try {
51636       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51637     } catch (std::out_of_range& e) {
51638       {
51639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51640       };
51641     } catch (std::exception& e) {
51642       {
51643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51644       };
51645     } catch (Dali::DaliException e) {
51646       {
51647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51648       };
51649     } catch (...) {
51650       {
51651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51652       };
51653     }
51654   }
51655
51656   jresult = (void *)result;
51657   return jresult;
51658 }
51659
51660
51661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51662   void * jresult ;
51663   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51664   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51665   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51666   Dali::Vector< int >::Iterator result;
51667
51668   arg1 = (Dali::Vector< int > *)jarg1;
51669   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51670   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51671   {
51672     try {
51673       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51674     } catch (std::out_of_range& e) {
51675       {
51676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51677       };
51678     } catch (std::exception& e) {
51679       {
51680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51681       };
51682     } catch (Dali::DaliException e) {
51683       {
51684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51685       };
51686     } catch (...) {
51687       {
51688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51689       };
51690     }
51691   }
51692
51693   jresult = (void *)result;
51694   return jresult;
51695 }
51696
51697
51698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51699   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51700   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51701
51702   arg1 = (Dali::Vector< int > *)jarg1;
51703   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51704   {
51705     try {
51706       (arg1)->Remove(arg2);
51707     } catch (std::out_of_range& e) {
51708       {
51709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51710       };
51711     } catch (std::exception& e) {
51712       {
51713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51714       };
51715     } catch (Dali::DaliException e) {
51716       {
51717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51718       };
51719     } catch (...) {
51720       {
51721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51722       };
51723     }
51724   }
51725
51726 }
51727
51728
51729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51730   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51731   Dali::Vector< int > *arg2 = 0 ;
51732
51733   arg1 = (Dali::Vector< int > *)jarg1;
51734   arg2 = (Dali::Vector< int > *)jarg2;
51735   if (!arg2) {
51736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51737     return ;
51738   }
51739   {
51740     try {
51741       (arg1)->Swap(*arg2);
51742     } catch (std::out_of_range& e) {
51743       {
51744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51745       };
51746     } catch (std::exception& e) {
51747       {
51748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51749       };
51750     } catch (Dali::DaliException e) {
51751       {
51752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51753       };
51754     } catch (...) {
51755       {
51756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51757       };
51758     }
51759   }
51760
51761 }
51762
51763
51764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51765   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51766
51767   arg1 = (Dali::Vector< int > *)jarg1;
51768   {
51769     try {
51770       (arg1)->Clear();
51771     } catch (std::out_of_range& e) {
51772       {
51773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51774       };
51775     } catch (std::exception& e) {
51776       {
51777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51778       };
51779     } catch (Dali::DaliException e) {
51780       {
51781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51782       };
51783     } catch (...) {
51784       {
51785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51786       };
51787     }
51788   }
51789
51790 }
51791
51792
51793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51794   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51795
51796   arg1 = (Dali::Vector< int > *)jarg1;
51797   {
51798     try {
51799       (arg1)->Release();
51800     } catch (std::out_of_range& e) {
51801       {
51802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51803       };
51804     } catch (std::exception& e) {
51805       {
51806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51807       };
51808     } catch (Dali::DaliException e) {
51809       {
51810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51811       };
51812     } catch (...) {
51813       {
51814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51815       };
51816     }
51817   }
51818
51819 }
51820
51821
51822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51823   int jresult ;
51824   int result;
51825
51826   result = (int)Dali::Vector< float >::BaseType;
51827   jresult = (int)result;
51828   return jresult;
51829 }
51830
51831
51832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51833   void * jresult ;
51834   Dali::Vector< float > *result = 0 ;
51835
51836   {
51837     try {
51838       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51839     } catch (std::out_of_range& e) {
51840       {
51841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51842       };
51843     } catch (std::exception& e) {
51844       {
51845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51846       };
51847     } catch (Dali::DaliException e) {
51848       {
51849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51850       };
51851     } catch (...) {
51852       {
51853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51854       };
51855     }
51856   }
51857
51858   jresult = (void *)result;
51859   return jresult;
51860 }
51861
51862
51863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51864   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51865
51866   arg1 = (Dali::Vector< float > *)jarg1;
51867   {
51868     try {
51869       delete arg1;
51870     } catch (std::out_of_range& e) {
51871       {
51872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51873       };
51874     } catch (std::exception& e) {
51875       {
51876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51877       };
51878     } catch (Dali::DaliException e) {
51879       {
51880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51881       };
51882     } catch (...) {
51883       {
51884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51885       };
51886     }
51887   }
51888
51889 }
51890
51891
51892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51893   void * jresult ;
51894   Dali::Vector< float > *arg1 = 0 ;
51895   Dali::Vector< float > *result = 0 ;
51896
51897   arg1 = (Dali::Vector< float > *)jarg1;
51898   if (!arg1) {
51899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51900     return 0;
51901   }
51902   {
51903     try {
51904       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51905     } catch (std::out_of_range& e) {
51906       {
51907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51908       };
51909     } catch (std::exception& e) {
51910       {
51911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51912       };
51913     } catch (Dali::DaliException e) {
51914       {
51915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51916       };
51917     } catch (...) {
51918       {
51919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51920       };
51921     }
51922   }
51923
51924   jresult = (void *)result;
51925   return jresult;
51926 }
51927
51928
51929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51930   void * jresult ;
51931   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51932   Dali::Vector< float > *arg2 = 0 ;
51933   Dali::Vector< float > *result = 0 ;
51934
51935   arg1 = (Dali::Vector< float > *)jarg1;
51936   arg2 = (Dali::Vector< float > *)jarg2;
51937   if (!arg2) {
51938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51939     return 0;
51940   }
51941   {
51942     try {
51943       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51944     } catch (std::out_of_range& e) {
51945       {
51946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51947       };
51948     } catch (std::exception& e) {
51949       {
51950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51951       };
51952     } catch (Dali::DaliException e) {
51953       {
51954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51955       };
51956     } catch (...) {
51957       {
51958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51959       };
51960     }
51961   }
51962
51963   jresult = (void *)result;
51964   return jresult;
51965 }
51966
51967
51968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51969   void * jresult ;
51970   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51971   Dali::Vector< float >::Iterator result;
51972
51973   arg1 = (Dali::Vector< float > *)jarg1;
51974   {
51975     try {
51976       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51977     } catch (std::out_of_range& e) {
51978       {
51979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51980       };
51981     } catch (std::exception& e) {
51982       {
51983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51984       };
51985     } catch (Dali::DaliException e) {
51986       {
51987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51988       };
51989     } catch (...) {
51990       {
51991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51992       };
51993     }
51994   }
51995
51996   jresult = (void *)result;
51997   return jresult;
51998 }
51999
52000
52001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
52002   void * jresult ;
52003   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52004   Dali::Vector< float >::Iterator result;
52005
52006   arg1 = (Dali::Vector< float > *)jarg1;
52007   {
52008     try {
52009       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
52010     } catch (std::out_of_range& e) {
52011       {
52012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52013       };
52014     } catch (std::exception& e) {
52015       {
52016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52017       };
52018     } catch (Dali::DaliException e) {
52019       {
52020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52021       };
52022     } catch (...) {
52023       {
52024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52025       };
52026     }
52027   }
52028
52029   jresult = (void *)result;
52030   return jresult;
52031 }
52032
52033
52034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52035   void * jresult ;
52036   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52037   Dali::Vector< float >::SizeType arg2 ;
52038   Dali::Vector< float >::ItemType *result = 0 ;
52039
52040   arg1 = (Dali::Vector< float > *)jarg1;
52041   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52042   {
52043     try {
52044       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
52045     } catch (std::out_of_range& e) {
52046       {
52047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52048       };
52049     } catch (std::exception& e) {
52050       {
52051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52052       };
52053     } catch (Dali::DaliException e) {
52054       {
52055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52056       };
52057     } catch (...) {
52058       {
52059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52060       };
52061     }
52062   }
52063
52064   jresult = (void *)result;
52065   return jresult;
52066 }
52067
52068
52069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
52070   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52071   Dali::Vector< float >::ItemType *arg2 = 0 ;
52072   Dali::Vector< float >::ItemType temp2 ;
52073
52074   arg1 = (Dali::Vector< float > *)jarg1;
52075   temp2 = (Dali::Vector< float >::ItemType)jarg2;
52076   arg2 = &temp2;
52077   {
52078     try {
52079       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
52080     } catch (std::out_of_range& e) {
52081       {
52082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52083       };
52084     } catch (std::exception& e) {
52085       {
52086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52087       };
52088     } catch (Dali::DaliException e) {
52089       {
52090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52091       };
52092     } catch (...) {
52093       {
52094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52095       };
52096     }
52097   }
52098
52099 }
52100
52101
52102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
52103   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52104   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52105   Dali::Vector< float >::ItemType *arg3 = 0 ;
52106   Dali::Vector< float >::ItemType temp3 ;
52107
52108   arg1 = (Dali::Vector< float > *)jarg1;
52109   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52110   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52111   arg3 = &temp3;
52112   {
52113     try {
52114       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52115     } catch (std::out_of_range& e) {
52116       {
52117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52118       };
52119     } catch (std::exception& e) {
52120       {
52121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52122       };
52123     } catch (Dali::DaliException e) {
52124       {
52125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52126       };
52127     } catch (...) {
52128       {
52129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52130       };
52131     }
52132   }
52133
52134 }
52135
52136
52137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52138   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52139   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52140   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52141   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52142
52143   arg1 = (Dali::Vector< float > *)jarg1;
52144   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52145   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52146   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52147   {
52148     try {
52149       (arg1)->Insert(arg2,arg3,arg4);
52150     } catch (std::out_of_range& e) {
52151       {
52152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52153       };
52154     } catch (std::exception& e) {
52155       {
52156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52157       };
52158     } catch (Dali::DaliException e) {
52159       {
52160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52161       };
52162     } catch (...) {
52163       {
52164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52165       };
52166     }
52167   }
52168
52169 }
52170
52171
52172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52173   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52174   Dali::Vector< float >::SizeType arg2 ;
52175
52176   arg1 = (Dali::Vector< float > *)jarg1;
52177   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52178   {
52179     try {
52180       (arg1)->Reserve(arg2);
52181     } catch (std::out_of_range& e) {
52182       {
52183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52184       };
52185     } catch (std::exception& e) {
52186       {
52187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52188       };
52189     } catch (Dali::DaliException e) {
52190       {
52191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52192       };
52193     } catch (...) {
52194       {
52195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52196       };
52197     }
52198   }
52199
52200 }
52201
52202 //// ========================= end of part 2 =============================
52203
52204 //// ========================== start part 3 ===============================
52205
52206
52207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52208   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52209   Dali::Vector< float >::SizeType arg2 ;
52210
52211   arg1 = (Dali::Vector< float > *)jarg1;
52212   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52213   {
52214     try {
52215       (arg1)->Resize(arg2);
52216     } catch (std::out_of_range& e) {
52217       {
52218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52219       };
52220     } catch (std::exception& e) {
52221       {
52222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52223       };
52224     } catch (Dali::DaliException e) {
52225       {
52226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52227       };
52228     } catch (...) {
52229       {
52230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52231       };
52232     }
52233   }
52234
52235 }
52236
52237
52238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52239   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52240   Dali::Vector< float >::SizeType arg2 ;
52241   Dali::Vector< float >::ItemType *arg3 = 0 ;
52242   Dali::Vector< float >::ItemType temp3 ;
52243
52244   arg1 = (Dali::Vector< float > *)jarg1;
52245   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52246   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52247   arg3 = &temp3;
52248   {
52249     try {
52250       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52251     } catch (std::out_of_range& e) {
52252       {
52253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52254       };
52255     } catch (std::exception& e) {
52256       {
52257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52258       };
52259     } catch (Dali::DaliException e) {
52260       {
52261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52262       };
52263     } catch (...) {
52264       {
52265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52266       };
52267     }
52268   }
52269
52270 }
52271
52272
52273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52274   void * jresult ;
52275   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52276   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52277   Dali::Vector< float >::Iterator result;
52278
52279   arg1 = (Dali::Vector< float > *)jarg1;
52280   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52281   {
52282     try {
52283       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52284     } catch (std::out_of_range& e) {
52285       {
52286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52287       };
52288     } catch (std::exception& e) {
52289       {
52290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52291       };
52292     } catch (Dali::DaliException e) {
52293       {
52294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52295       };
52296     } catch (...) {
52297       {
52298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52299       };
52300     }
52301   }
52302
52303   jresult = (void *)result;
52304   return jresult;
52305 }
52306
52307
52308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52309   void * jresult ;
52310   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52311   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52312   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52313   Dali::Vector< float >::Iterator result;
52314
52315   arg1 = (Dali::Vector< float > *)jarg1;
52316   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52317   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52318   {
52319     try {
52320       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52321     } catch (std::out_of_range& e) {
52322       {
52323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52324       };
52325     } catch (std::exception& e) {
52326       {
52327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52328       };
52329     } catch (Dali::DaliException e) {
52330       {
52331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52332       };
52333     } catch (...) {
52334       {
52335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52336       };
52337     }
52338   }
52339
52340   jresult = (void *)result;
52341   return jresult;
52342 }
52343
52344
52345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52346   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52347   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52348
52349   arg1 = (Dali::Vector< float > *)jarg1;
52350   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52351   {
52352     try {
52353       (arg1)->Remove(arg2);
52354     } catch (std::out_of_range& e) {
52355       {
52356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52357       };
52358     } catch (std::exception& e) {
52359       {
52360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52361       };
52362     } catch (Dali::DaliException e) {
52363       {
52364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52365       };
52366     } catch (...) {
52367       {
52368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52369       };
52370     }
52371   }
52372
52373 }
52374
52375
52376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52377   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52378   Dali::Vector< float > *arg2 = 0 ;
52379
52380   arg1 = (Dali::Vector< float > *)jarg1;
52381   arg2 = (Dali::Vector< float > *)jarg2;
52382   if (!arg2) {
52383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52384     return ;
52385   }
52386   {
52387     try {
52388       (arg1)->Swap(*arg2);
52389     } catch (std::out_of_range& e) {
52390       {
52391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52392       };
52393     } catch (std::exception& e) {
52394       {
52395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52396       };
52397     } catch (Dali::DaliException e) {
52398       {
52399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52400       };
52401     } catch (...) {
52402       {
52403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52404       };
52405     }
52406   }
52407
52408 }
52409
52410
52411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52412   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52413
52414   arg1 = (Dali::Vector< float > *)jarg1;
52415   {
52416     try {
52417       (arg1)->Clear();
52418     } catch (std::out_of_range& e) {
52419       {
52420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52421       };
52422     } catch (std::exception& e) {
52423       {
52424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52425       };
52426     } catch (Dali::DaliException e) {
52427       {
52428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52429       };
52430     } catch (...) {
52431       {
52432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52433       };
52434     }
52435   }
52436
52437 }
52438
52439
52440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52441   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52442
52443   arg1 = (Dali::Vector< float > *)jarg1;
52444   {
52445     try {
52446       (arg1)->Release();
52447     } catch (std::out_of_range& e) {
52448       {
52449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52450       };
52451     } catch (std::exception& e) {
52452       {
52453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52454       };
52455     } catch (Dali::DaliException e) {
52456       {
52457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52458       };
52459     } catch (...) {
52460       {
52461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52462       };
52463     }
52464   }
52465
52466 }
52467
52468
52469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52470   int jresult ;
52471   int result;
52472
52473   result = (int)Dali::Vector< unsigned char >::BaseType;
52474   jresult = (int)result;
52475   return jresult;
52476 }
52477
52478
52479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52480   void * jresult ;
52481   Dali::Vector< unsigned char > *result = 0 ;
52482
52483   {
52484     try {
52485       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52486     } catch (std::out_of_range& e) {
52487       {
52488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52489       };
52490     } catch (std::exception& e) {
52491       {
52492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52493       };
52494     } catch (Dali::DaliException e) {
52495       {
52496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52497       };
52498     } catch (...) {
52499       {
52500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52501       };
52502     }
52503   }
52504
52505   jresult = (void *)result;
52506   return jresult;
52507 }
52508
52509
52510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52511   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52512
52513   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52514   {
52515     try {
52516       delete arg1;
52517     } catch (std::out_of_range& e) {
52518       {
52519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52520       };
52521     } catch (std::exception& e) {
52522       {
52523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52524       };
52525     } catch (Dali::DaliException e) {
52526       {
52527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52528       };
52529     } catch (...) {
52530       {
52531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52532       };
52533     }
52534   }
52535
52536 }
52537
52538
52539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52540   void * jresult ;
52541   Dali::Vector< unsigned char > *arg1 = 0 ;
52542   Dali::Vector< unsigned char > *result = 0 ;
52543
52544   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52545   if (!arg1) {
52546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52547     return 0;
52548   }
52549   {
52550     try {
52551       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52552     } catch (std::out_of_range& e) {
52553       {
52554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52555       };
52556     } catch (std::exception& e) {
52557       {
52558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52559       };
52560     } catch (Dali::DaliException e) {
52561       {
52562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52563       };
52564     } catch (...) {
52565       {
52566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52567       };
52568     }
52569   }
52570
52571   jresult = (void *)result;
52572   return jresult;
52573 }
52574
52575
52576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52577   void * jresult ;
52578   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52579   Dali::Vector< unsigned char > *arg2 = 0 ;
52580   Dali::Vector< unsigned char > *result = 0 ;
52581
52582   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52583   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52584   if (!arg2) {
52585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52586     return 0;
52587   }
52588   {
52589     try {
52590       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52591     } catch (std::out_of_range& e) {
52592       {
52593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52594       };
52595     } catch (std::exception& e) {
52596       {
52597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52598       };
52599     } catch (Dali::DaliException e) {
52600       {
52601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52602       };
52603     } catch (...) {
52604       {
52605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52606       };
52607     }
52608   }
52609
52610   jresult = (void *)result;
52611   return jresult;
52612 }
52613
52614
52615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52616   void * jresult ;
52617   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52618   Dali::Vector< unsigned char >::Iterator result;
52619
52620   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52621   {
52622     try {
52623       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52624     } catch (std::out_of_range& e) {
52625       {
52626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52627       };
52628     } catch (std::exception& e) {
52629       {
52630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52631       };
52632     } catch (Dali::DaliException e) {
52633       {
52634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52635       };
52636     } catch (...) {
52637       {
52638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52639       };
52640     }
52641   }
52642
52643   jresult = (void *)result;
52644   return jresult;
52645 }
52646
52647
52648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52649   void * jresult ;
52650   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52651   Dali::Vector< unsigned char >::Iterator result;
52652
52653   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52654   {
52655     try {
52656       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52657     } catch (std::out_of_range& e) {
52658       {
52659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52660       };
52661     } catch (std::exception& e) {
52662       {
52663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52664       };
52665     } catch (Dali::DaliException e) {
52666       {
52667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52668       };
52669     } catch (...) {
52670       {
52671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52672       };
52673     }
52674   }
52675
52676   jresult = (void *)result;
52677   return jresult;
52678 }
52679
52680
52681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52682   void * jresult ;
52683   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52684   Dali::Vector< unsigned char >::SizeType arg2 ;
52685   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52686
52687   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52688   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52689   {
52690     try {
52691       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52692     } catch (std::out_of_range& e) {
52693       {
52694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52695       };
52696     } catch (std::exception& e) {
52697       {
52698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52699       };
52700     } catch (Dali::DaliException e) {
52701       {
52702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52703       };
52704     } catch (...) {
52705       {
52706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52707       };
52708     }
52709   }
52710
52711   jresult = (void *)result;
52712   return jresult;
52713 }
52714
52715
52716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52717   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52718   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52719   Dali::Vector< unsigned char >::ItemType temp2 ;
52720
52721   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52722   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52723   arg2 = &temp2;
52724   {
52725     try {
52726       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52727     } catch (std::out_of_range& e) {
52728       {
52729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52730       };
52731     } catch (std::exception& e) {
52732       {
52733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52734       };
52735     } catch (Dali::DaliException e) {
52736       {
52737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52738       };
52739     } catch (...) {
52740       {
52741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52742       };
52743     }
52744   }
52745
52746 }
52747
52748
52749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52750   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52751   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52752   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52753   Dali::Vector< unsigned char >::ItemType temp3 ;
52754
52755   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52756   arg2 = jarg2;
52757   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52758   arg3 = &temp3;
52759   {
52760     try {
52761       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52762     } catch (std::out_of_range& e) {
52763       {
52764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52765       };
52766     } catch (std::exception& e) {
52767       {
52768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52769       };
52770     } catch (Dali::DaliException e) {
52771       {
52772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52773       };
52774     } catch (...) {
52775       {
52776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52777       };
52778     }
52779   }
52780
52781
52782
52783 }
52784
52785
52786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52787   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52788   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52789   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52790   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52791
52792   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52793   arg2 = jarg2;
52794   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52795   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52796   {
52797     try {
52798       (arg1)->Insert(arg2,arg3,arg4);
52799     } catch (std::out_of_range& e) {
52800       {
52801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52802       };
52803     } catch (std::exception& e) {
52804       {
52805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52806       };
52807     } catch (Dali::DaliException e) {
52808       {
52809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52810       };
52811     } catch (...) {
52812       {
52813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52814       };
52815     }
52816   }
52817
52818
52819
52820 }
52821
52822
52823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52824   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52825   Dali::Vector< unsigned char >::SizeType arg2 ;
52826
52827   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52828   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52829   {
52830     try {
52831       (arg1)->Reserve(arg2);
52832     } catch (std::out_of_range& e) {
52833       {
52834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52835       };
52836     } catch (std::exception& e) {
52837       {
52838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52839       };
52840     } catch (Dali::DaliException e) {
52841       {
52842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52843       };
52844     } catch (...) {
52845       {
52846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52847       };
52848     }
52849   }
52850
52851 }
52852
52853
52854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52855   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52856   Dali::Vector< unsigned char >::SizeType arg2 ;
52857
52858   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52859   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52860   {
52861     try {
52862       (arg1)->Resize(arg2);
52863     } catch (std::out_of_range& e) {
52864       {
52865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52866       };
52867     } catch (std::exception& e) {
52868       {
52869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52870       };
52871     } catch (Dali::DaliException e) {
52872       {
52873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52874       };
52875     } catch (...) {
52876       {
52877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52878       };
52879     }
52880   }
52881
52882 }
52883
52884
52885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52886   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52887   Dali::Vector< unsigned char >::SizeType arg2 ;
52888   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52889   Dali::Vector< unsigned char >::ItemType temp3 ;
52890
52891   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52892   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52893   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52894   arg3 = &temp3;
52895   {
52896     try {
52897       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52898     } catch (std::out_of_range& e) {
52899       {
52900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52901       };
52902     } catch (std::exception& e) {
52903       {
52904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52905       };
52906     } catch (Dali::DaliException e) {
52907       {
52908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52909       };
52910     } catch (...) {
52911       {
52912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52913       };
52914     }
52915   }
52916
52917 }
52918
52919
52920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52921   void * jresult ;
52922   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52923   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52924   Dali::Vector< unsigned char >::Iterator result;
52925
52926   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52927   arg2 = jarg2;
52928   {
52929     try {
52930       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52931     } catch (std::out_of_range& e) {
52932       {
52933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52934       };
52935     } catch (std::exception& e) {
52936       {
52937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52938       };
52939     } catch (Dali::DaliException e) {
52940       {
52941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52942       };
52943     } catch (...) {
52944       {
52945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52946       };
52947     }
52948   }
52949
52950   jresult = (void *)result;
52951
52952
52953   return jresult;
52954 }
52955
52956
52957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52958   void * jresult ;
52959   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52960   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52961   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52962   Dali::Vector< unsigned char >::Iterator result;
52963
52964   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52965   arg2 = jarg2;
52966   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52967   {
52968     try {
52969       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52970     } catch (std::out_of_range& e) {
52971       {
52972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52973       };
52974     } catch (std::exception& e) {
52975       {
52976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52977       };
52978     } catch (Dali::DaliException e) {
52979       {
52980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52981       };
52982     } catch (...) {
52983       {
52984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52985       };
52986     }
52987   }
52988
52989   jresult = (void *)result;
52990
52991
52992   return jresult;
52993 }
52994
52995
52996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52997   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52998   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52999
53000   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53001   arg2 = jarg2;
53002   {
53003     try {
53004       (arg1)->Remove(arg2);
53005     } catch (std::out_of_range& e) {
53006       {
53007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53008       };
53009     } catch (std::exception& e) {
53010       {
53011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53012       };
53013     } catch (Dali::DaliException e) {
53014       {
53015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53016       };
53017     } catch (...) {
53018       {
53019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53020       };
53021     }
53022   }
53023
53024
53025
53026 }
53027
53028
53029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
53030   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53031   Dali::Vector< unsigned char > *arg2 = 0 ;
53032
53033   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53034   arg2 = (Dali::Vector< unsigned char > *)jarg2;
53035   if (!arg2) {
53036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
53037     return ;
53038   }
53039   {
53040     try {
53041       (arg1)->Swap(*arg2);
53042     } catch (std::out_of_range& e) {
53043       {
53044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53045       };
53046     } catch (std::exception& e) {
53047       {
53048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53049       };
53050     } catch (Dali::DaliException e) {
53051       {
53052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53053       };
53054     } catch (...) {
53055       {
53056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53057       };
53058     }
53059   }
53060
53061 }
53062
53063
53064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
53065   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53066
53067   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53068   {
53069     try {
53070       (arg1)->Clear();
53071     } catch (std::out_of_range& e) {
53072       {
53073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53074       };
53075     } catch (std::exception& e) {
53076       {
53077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53078       };
53079     } catch (Dali::DaliException e) {
53080       {
53081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53082       };
53083     } catch (...) {
53084       {
53085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53086       };
53087     }
53088   }
53089
53090 }
53091
53092
53093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
53094   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53095
53096   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53097   {
53098     try {
53099       (arg1)->Release();
53100     } catch (std::out_of_range& e) {
53101       {
53102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53103       };
53104     } catch (std::exception& e) {
53105       {
53106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53107       };
53108     } catch (Dali::DaliException e) {
53109       {
53110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53111       };
53112     } catch (...) {
53113       {
53114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53115       };
53116     }
53117   }
53118
53119 }
53120
53121
53122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53123   int jresult ;
53124   int result;
53125
53126   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53127   jresult = (int)result;
53128   return jresult;
53129 }
53130
53131
53132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53133   void * jresult ;
53134   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53135
53136   {
53137     try {
53138       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53139     } catch (std::out_of_range& e) {
53140       {
53141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53142       };
53143     } catch (std::exception& e) {
53144       {
53145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53146       };
53147     } catch (Dali::DaliException e) {
53148       {
53149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53150       };
53151     } catch (...) {
53152       {
53153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53154       };
53155     }
53156   }
53157
53158   jresult = (void *)result;
53159   return jresult;
53160 }
53161
53162
53163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53164   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53165
53166   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53167   {
53168     try {
53169       delete arg1;
53170     } catch (std::out_of_range& e) {
53171       {
53172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53173       };
53174     } catch (std::exception& e) {
53175       {
53176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53177       };
53178     } catch (Dali::DaliException e) {
53179       {
53180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53181       };
53182     } catch (...) {
53183       {
53184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53185       };
53186     }
53187   }
53188
53189 }
53190
53191
53192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53193   void * jresult ;
53194   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53195   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53196
53197   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53198   if (!arg1) {
53199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53200     return 0;
53201   }
53202   {
53203     try {
53204       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53205     } catch (std::out_of_range& e) {
53206       {
53207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53208       };
53209     } catch (std::exception& e) {
53210       {
53211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53212       };
53213     } catch (Dali::DaliException e) {
53214       {
53215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53216       };
53217     } catch (...) {
53218       {
53219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53220       };
53221     }
53222   }
53223
53224   jresult = (void *)result;
53225   return jresult;
53226 }
53227
53228
53229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53230   void * jresult ;
53231   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53232   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53233   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53234
53235   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53236   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53237   if (!arg2) {
53238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53239     return 0;
53240   }
53241   {
53242     try {
53243       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53244     } catch (std::out_of_range& e) {
53245       {
53246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53247       };
53248     } catch (std::exception& e) {
53249       {
53250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53251       };
53252     } catch (Dali::DaliException e) {
53253       {
53254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53255       };
53256     } catch (...) {
53257       {
53258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53259       };
53260     }
53261   }
53262
53263   jresult = (void *)result;
53264   return jresult;
53265 }
53266
53267
53268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53269   void * jresult ;
53270   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53271   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53272
53273   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53274   {
53275     try {
53276       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53277     } catch (std::out_of_range& e) {
53278       {
53279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53280       };
53281     } catch (std::exception& e) {
53282       {
53283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53284       };
53285     } catch (Dali::DaliException e) {
53286       {
53287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53288       };
53289     } catch (...) {
53290       {
53291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53292       };
53293     }
53294   }
53295
53296   jresult = (void *)result;
53297   return jresult;
53298 }
53299
53300
53301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53302   void * jresult ;
53303   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53304   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53305
53306   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53307   {
53308     try {
53309       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53310     } catch (std::out_of_range& e) {
53311       {
53312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53313       };
53314     } catch (std::exception& e) {
53315       {
53316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53317       };
53318     } catch (Dali::DaliException e) {
53319       {
53320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53321       };
53322     } catch (...) {
53323       {
53324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53325       };
53326     }
53327   }
53328
53329   jresult = (void *)result;
53330   return jresult;
53331 }
53332
53333
53334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53335   void * jresult ;
53336   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53337   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53338   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53339
53340   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53341   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53342   {
53343     try {
53344       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53345     } catch (std::out_of_range& e) {
53346       {
53347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53348       };
53349     } catch (std::exception& e) {
53350       {
53351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53352       };
53353     } catch (Dali::DaliException e) {
53354       {
53355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53356       };
53357     } catch (...) {
53358       {
53359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53360       };
53361     }
53362   }
53363
53364   jresult = (void *)result;
53365   return jresult;
53366 }
53367
53368
53369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53370   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53371   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53372
53373   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53374   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53375   if (!arg2) {
53376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53377     return ;
53378   }
53379   {
53380     try {
53381       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53382     } catch (std::out_of_range& e) {
53383       {
53384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53385       };
53386     } catch (std::exception& e) {
53387       {
53388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53389       };
53390     } catch (Dali::DaliException e) {
53391       {
53392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53393       };
53394     } catch (...) {
53395       {
53396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53397       };
53398     }
53399   }
53400
53401 }
53402
53403
53404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53405   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53406   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53407   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53408
53409   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53410   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53411   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53412   if (!arg3) {
53413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53414     return ;
53415   }
53416   {
53417     try {
53418       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53419     } catch (std::out_of_range& e) {
53420       {
53421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53422       };
53423     } catch (std::exception& e) {
53424       {
53425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53426       };
53427     } catch (Dali::DaliException e) {
53428       {
53429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53430       };
53431     } catch (...) {
53432       {
53433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53434       };
53435     }
53436   }
53437
53438 }
53439
53440
53441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53442   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53443   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53444   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53445   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53446
53447   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53448   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53449   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53450   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53451   {
53452     try {
53453       (arg1)->Insert(arg2,arg3,arg4);
53454     } catch (std::out_of_range& e) {
53455       {
53456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53457       };
53458     } catch (std::exception& e) {
53459       {
53460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53461       };
53462     } catch (Dali::DaliException e) {
53463       {
53464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53465       };
53466     } catch (...) {
53467       {
53468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53469       };
53470     }
53471   }
53472
53473 }
53474
53475
53476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53477   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53478   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53479
53480   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53481   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53482   {
53483     try {
53484       (arg1)->Reserve(arg2);
53485     } catch (std::out_of_range& e) {
53486       {
53487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53488       };
53489     } catch (std::exception& e) {
53490       {
53491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53492       };
53493     } catch (Dali::DaliException e) {
53494       {
53495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53496       };
53497     } catch (...) {
53498       {
53499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53500       };
53501     }
53502   }
53503
53504 }
53505
53506
53507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53508   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53509   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53510
53511   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53512   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53513   {
53514     try {
53515       (arg1)->Resize(arg2);
53516     } catch (std::out_of_range& e) {
53517       {
53518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53519       };
53520     } catch (std::exception& e) {
53521       {
53522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53523       };
53524     } catch (Dali::DaliException e) {
53525       {
53526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53527       };
53528     } catch (...) {
53529       {
53530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53531       };
53532     }
53533   }
53534
53535 }
53536
53537
53538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53539   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53540   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53541   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53542
53543   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53544   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53545   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53546   if (!arg3) {
53547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53548     return ;
53549   }
53550   {
53551     try {
53552       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53553     } catch (std::out_of_range& e) {
53554       {
53555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53556       };
53557     } catch (std::exception& e) {
53558       {
53559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53560       };
53561     } catch (Dali::DaliException e) {
53562       {
53563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53564       };
53565     } catch (...) {
53566       {
53567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53568       };
53569     }
53570   }
53571
53572 }
53573
53574
53575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53576   void * jresult ;
53577   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53578   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53579   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53580
53581   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53582   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53583   {
53584     try {
53585       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53586     } catch (std::out_of_range& e) {
53587       {
53588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53589       };
53590     } catch (std::exception& e) {
53591       {
53592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53593       };
53594     } catch (Dali::DaliException e) {
53595       {
53596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53597       };
53598     } catch (...) {
53599       {
53600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53601       };
53602     }
53603   }
53604
53605   jresult = (void *)result;
53606   return jresult;
53607 }
53608
53609
53610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53611   void * jresult ;
53612   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53613   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53614   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53615   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53616
53617   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53618   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53619   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53620   {
53621     try {
53622       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53623     } catch (std::out_of_range& e) {
53624       {
53625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53626       };
53627     } catch (std::exception& e) {
53628       {
53629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53630       };
53631     } catch (Dali::DaliException e) {
53632       {
53633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53634       };
53635     } catch (...) {
53636       {
53637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53638       };
53639     }
53640   }
53641
53642   jresult = (void *)result;
53643   return jresult;
53644 }
53645
53646
53647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53648   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53649   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53650
53651   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53652   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53653   {
53654     try {
53655       (arg1)->Remove(arg2);
53656     } catch (std::out_of_range& e) {
53657       {
53658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53659       };
53660     } catch (std::exception& e) {
53661       {
53662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53663       };
53664     } catch (Dali::DaliException e) {
53665       {
53666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53667       };
53668     } catch (...) {
53669       {
53670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53671       };
53672     }
53673   }
53674
53675 }
53676
53677
53678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53679   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53680   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53681
53682   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53683   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53684   if (!arg2) {
53685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53686     return ;
53687   }
53688   {
53689     try {
53690       (arg1)->Swap(*arg2);
53691     } catch (std::out_of_range& e) {
53692       {
53693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53694       };
53695     } catch (std::exception& e) {
53696       {
53697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53698       };
53699     } catch (Dali::DaliException e) {
53700       {
53701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53702       };
53703     } catch (...) {
53704       {
53705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53706       };
53707     }
53708   }
53709
53710 }
53711
53712
53713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53714   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53715
53716   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53717   {
53718     try {
53719       (arg1)->Clear();
53720     } catch (std::out_of_range& e) {
53721       {
53722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53723       };
53724     } catch (std::exception& e) {
53725       {
53726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53727       };
53728     } catch (Dali::DaliException e) {
53729       {
53730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53731       };
53732     } catch (...) {
53733       {
53734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53735       };
53736     }
53737   }
53738
53739 }
53740
53741
53742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53743   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53744
53745   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53746   {
53747     try {
53748       (arg1)->Release();
53749     } catch (std::out_of_range& e) {
53750       {
53751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53752       };
53753     } catch (std::exception& e) {
53754       {
53755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53756       };
53757     } catch (Dali::DaliException e) {
53758       {
53759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53760       };
53761     } catch (...) {
53762       {
53763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53764       };
53765     }
53766   }
53767
53768 }
53769
53770
53771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53772   void * jresult ;
53773   Dali::Signal< void () > *result = 0 ;
53774
53775   {
53776     try {
53777       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53778     } catch (std::out_of_range& e) {
53779       {
53780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53781       };
53782     } catch (std::exception& e) {
53783       {
53784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53785       };
53786     } catch (Dali::DaliException e) {
53787       {
53788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53789       };
53790     } catch (...) {
53791       {
53792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53793       };
53794     }
53795   }
53796
53797   jresult = (void *)result;
53798   return jresult;
53799 }
53800
53801
53802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53803   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53804
53805   arg1 = (Dali::Signal< void () > *)jarg1;
53806   {
53807     try {
53808       delete arg1;
53809     } catch (std::out_of_range& e) {
53810       {
53811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53812       };
53813     } catch (std::exception& e) {
53814       {
53815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53816       };
53817     } catch (Dali::DaliException e) {
53818       {
53819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53820       };
53821     } catch (...) {
53822       {
53823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53824       };
53825     }
53826   }
53827
53828 }
53829
53830
53831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53832   unsigned int jresult ;
53833   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53834   bool result;
53835
53836   arg1 = (Dali::Signal< void () > *)jarg1;
53837   {
53838     try {
53839       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53840     } catch (std::out_of_range& e) {
53841       {
53842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53843       };
53844     } catch (std::exception& e) {
53845       {
53846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53847       };
53848     } catch (Dali::DaliException e) {
53849       {
53850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53851       };
53852     } catch (...) {
53853       {
53854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53855       };
53856     }
53857   }
53858
53859   jresult = result;
53860   return jresult;
53861 }
53862
53863
53864 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53865   unsigned long jresult ;
53866   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53867   std::size_t result;
53868
53869   arg1 = (Dali::Signal< void () > *)jarg1;
53870   {
53871     try {
53872       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53873     } catch (std::out_of_range& e) {
53874       {
53875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53876       };
53877     } catch (std::exception& e) {
53878       {
53879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53880       };
53881     } catch (Dali::DaliException e) {
53882       {
53883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53884       };
53885     } catch (...) {
53886       {
53887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53888       };
53889     }
53890   }
53891
53892   jresult = (unsigned long)result;
53893   return jresult;
53894 }
53895
53896
53897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53898   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53899   void (*arg2)() = (void (*)()) 0 ;
53900
53901   arg1 = (Dali::Signal< void () > *)jarg1;
53902   arg2 = (void (*)())jarg2;
53903   {
53904     try {
53905       (arg1)->Connect(arg2);
53906     } catch (std::out_of_range& e) {
53907       {
53908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53909       };
53910     } catch (std::exception& e) {
53911       {
53912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53913       };
53914     } catch (Dali::DaliException e) {
53915       {
53916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53917       };
53918     } catch (...) {
53919       {
53920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53921       };
53922     }
53923   }
53924
53925 }
53926
53927
53928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53929   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53930   void (*arg2)() = (void (*)()) 0 ;
53931
53932   arg1 = (Dali::Signal< void () > *)jarg1;
53933   arg2 = (void (*)())jarg2;
53934   {
53935     try {
53936       (arg1)->Disconnect(arg2);
53937     } catch (std::out_of_range& e) {
53938       {
53939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53940       };
53941     } catch (std::exception& e) {
53942       {
53943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53944       };
53945     } catch (Dali::DaliException e) {
53946       {
53947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53948       };
53949     } catch (...) {
53950       {
53951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53952       };
53953     }
53954   }
53955
53956 }
53957
53958
53959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53960   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53961   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53962   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53963
53964   arg1 = (Dali::Signal< void () > *)jarg1;
53965   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53966   arg3 = (Dali::FunctorDelegate *)jarg3;
53967   {
53968     try {
53969       (arg1)->Connect(arg2,arg3);
53970     } catch (std::out_of_range& e) {
53971       {
53972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53973       };
53974     } catch (std::exception& e) {
53975       {
53976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53977       };
53978     } catch (Dali::DaliException e) {
53979       {
53980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53981       };
53982     } catch (...) {
53983       {
53984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53985       };
53986     }
53987   }
53988
53989 }
53990
53991
53992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53993   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53994
53995   arg1 = (Dali::Signal< void () > *)jarg1;
53996   {
53997     try {
53998       (arg1)->Emit();
53999     } catch (std::out_of_range& e) {
54000       {
54001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54002       };
54003     } catch (std::exception& e) {
54004       {
54005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54006       };
54007     } catch (Dali::DaliException e) {
54008       {
54009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54010       };
54011     } catch (...) {
54012       {
54013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54014       };
54015     }
54016   }
54017
54018 }
54019
54020
54021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
54022   unsigned int jresult ;
54023   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54024   bool result;
54025
54026   arg1 = (Dali::Signal< void (float) > *)jarg1;
54027   {
54028     try {
54029       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
54030     } catch (std::out_of_range& e) {
54031       {
54032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54033       };
54034     } catch (std::exception& e) {
54035       {
54036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54037       };
54038     } catch (Dali::DaliException e) {
54039       {
54040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54041       };
54042     } catch (...) {
54043       {
54044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54045       };
54046     }
54047   }
54048
54049   jresult = result;
54050   return jresult;
54051 }
54052
54053
54054 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
54055   unsigned long jresult ;
54056   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54057   std::size_t result;
54058
54059   arg1 = (Dali::Signal< void (float) > *)jarg1;
54060   {
54061     try {
54062       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
54063     } catch (std::out_of_range& e) {
54064       {
54065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54066       };
54067     } catch (std::exception& e) {
54068       {
54069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54070       };
54071     } catch (Dali::DaliException e) {
54072       {
54073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54074       };
54075     } catch (...) {
54076       {
54077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54078       };
54079     }
54080   }
54081
54082   jresult = (unsigned long)result;
54083   return jresult;
54084 }
54085
54086
54087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
54088   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54089   void (*arg2)(float) = (void (*)(float)) 0 ;
54090
54091   arg1 = (Dali::Signal< void (float) > *)jarg1;
54092   arg2 = (void (*)(float))jarg2;
54093   {
54094     try {
54095       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
54096     } catch (std::out_of_range& e) {
54097       {
54098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54099       };
54100     } catch (std::exception& e) {
54101       {
54102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54103       };
54104     } catch (Dali::DaliException e) {
54105       {
54106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54107       };
54108     } catch (...) {
54109       {
54110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54111       };
54112     }
54113   }
54114
54115 }
54116
54117
54118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54119   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54120   void (*arg2)(float) = (void (*)(float)) 0 ;
54121
54122   arg1 = (Dali::Signal< void (float) > *)jarg1;
54123   arg2 = (void (*)(float))jarg2;
54124   {
54125     try {
54126       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54127     } catch (std::out_of_range& e) {
54128       {
54129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54130       };
54131     } catch (std::exception& e) {
54132       {
54133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54134       };
54135     } catch (Dali::DaliException e) {
54136       {
54137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54138       };
54139     } catch (...) {
54140       {
54141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54142       };
54143     }
54144   }
54145
54146 }
54147
54148
54149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54150   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54151   float arg2 ;
54152
54153   arg1 = (Dali::Signal< void (float) > *)jarg1;
54154   arg2 = (float)jarg2;
54155   {
54156     try {
54157       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54158     } catch (std::out_of_range& e) {
54159       {
54160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54161       };
54162     } catch (std::exception& e) {
54163       {
54164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54165       };
54166     } catch (Dali::DaliException e) {
54167       {
54168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54169       };
54170     } catch (...) {
54171       {
54172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54173       };
54174     }
54175   }
54176
54177 }
54178
54179
54180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54181   void * jresult ;
54182   Dali::Signal< void (float) > *result = 0 ;
54183
54184   {
54185     try {
54186       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54187     } catch (std::out_of_range& e) {
54188       {
54189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54190       };
54191     } catch (std::exception& e) {
54192       {
54193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54194       };
54195     } catch (Dali::DaliException e) {
54196       {
54197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54198       };
54199     } catch (...) {
54200       {
54201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54202       };
54203     }
54204   }
54205
54206   jresult = (void *)result;
54207   return jresult;
54208 }
54209
54210
54211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54212   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54213
54214   arg1 = (Dali::Signal< void (float) > *)jarg1;
54215   {
54216     try {
54217       delete arg1;
54218     } catch (std::out_of_range& e) {
54219       {
54220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54221       };
54222     } catch (std::exception& e) {
54223       {
54224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54225       };
54226     } catch (Dali::DaliException e) {
54227       {
54228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54229       };
54230     } catch (...) {
54231       {
54232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54233       };
54234     }
54235   }
54236
54237 }
54238
54239
54240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54241   unsigned int jresult ;
54242   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54243   bool result;
54244
54245   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54246   {
54247     try {
54248       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54249     } catch (std::out_of_range& e) {
54250       {
54251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54252       };
54253     } catch (std::exception& e) {
54254       {
54255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54256       };
54257     } catch (Dali::DaliException e) {
54258       {
54259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54260       };
54261     } catch (...) {
54262       {
54263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54264       };
54265     }
54266   }
54267
54268   jresult = result;
54269   return jresult;
54270 }
54271
54272
54273 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54274   unsigned long jresult ;
54275   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54276   std::size_t result;
54277
54278   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54279   {
54280     try {
54281       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54282     } catch (std::out_of_range& e) {
54283       {
54284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54285       };
54286     } catch (std::exception& e) {
54287       {
54288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54289       };
54290     } catch (Dali::DaliException e) {
54291       {
54292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54293       };
54294     } catch (...) {
54295       {
54296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54297       };
54298     }
54299   }
54300
54301   jresult = (unsigned long)result;
54302   return jresult;
54303 }
54304
54305
54306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54307   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54308   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54309
54310   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54311   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54312   {
54313     try {
54314       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54315     } catch (std::out_of_range& e) {
54316       {
54317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54318       };
54319     } catch (std::exception& e) {
54320       {
54321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54322       };
54323     } catch (Dali::DaliException e) {
54324       {
54325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54326       };
54327     } catch (...) {
54328       {
54329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54330       };
54331     }
54332   }
54333
54334 }
54335
54336
54337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54338   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54339   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54340
54341   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54342   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54343   {
54344     try {
54345       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54346     } catch (std::out_of_range& e) {
54347       {
54348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54349       };
54350     } catch (std::exception& e) {
54351       {
54352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54353       };
54354     } catch (Dali::DaliException e) {
54355       {
54356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54357       };
54358     } catch (...) {
54359       {
54360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54361       };
54362     }
54363   }
54364
54365 }
54366
54367
54368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54369   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54370   Dali::BaseHandle arg2 ;
54371   Dali::BaseHandle *argp2 ;
54372
54373   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54374   argp2 = (Dali::BaseHandle *)jarg2;
54375   if (!argp2) {
54376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54377     return ;
54378   }
54379   arg2 = *argp2;
54380   {
54381     try {
54382       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54383     } catch (std::out_of_range& e) {
54384       {
54385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54386       };
54387     } catch (std::exception& e) {
54388       {
54389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54390       };
54391     } catch (Dali::DaliException e) {
54392       {
54393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54394       };
54395     } catch (...) {
54396       {
54397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54398       };
54399     }
54400   }
54401
54402 }
54403
54404
54405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54406   void * jresult ;
54407   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54408
54409   {
54410     try {
54411       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54412     } catch (std::out_of_range& e) {
54413       {
54414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54415       };
54416     } catch (std::exception& e) {
54417       {
54418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54419       };
54420     } catch (Dali::DaliException e) {
54421       {
54422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54423       };
54424     } catch (...) {
54425       {
54426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54427       };
54428     }
54429   }
54430
54431   jresult = (void *)result;
54432   return jresult;
54433 }
54434
54435
54436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54437   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54438
54439   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54440   {
54441     try {
54442       delete arg1;
54443     } catch (std::out_of_range& e) {
54444       {
54445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54446       };
54447     } catch (std::exception& e) {
54448       {
54449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54450       };
54451     } catch (Dali::DaliException e) {
54452       {
54453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54454       };
54455     } catch (...) {
54456       {
54457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54458       };
54459     }
54460   }
54461
54462 }
54463
54464
54465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54466   unsigned int jresult ;
54467   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54468   bool result;
54469
54470   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54471   {
54472     try {
54473       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54474     } catch (std::out_of_range& e) {
54475       {
54476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54477       };
54478     } catch (std::exception& e) {
54479       {
54480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54481       };
54482     } catch (Dali::DaliException e) {
54483       {
54484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54485       };
54486     } catch (...) {
54487       {
54488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54489       };
54490     }
54491   }
54492
54493   jresult = result;
54494   return jresult;
54495 }
54496
54497
54498 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54499   unsigned long jresult ;
54500   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54501   std::size_t result;
54502
54503   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54504   {
54505     try {
54506       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54507     } catch (std::out_of_range& e) {
54508       {
54509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54510       };
54511     } catch (std::exception& e) {
54512       {
54513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54514       };
54515     } catch (Dali::DaliException e) {
54516       {
54517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54518       };
54519     } catch (...) {
54520       {
54521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54522       };
54523     }
54524   }
54525
54526   jresult = (unsigned long)result;
54527   return jresult;
54528 }
54529
54530
54531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54532   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54533   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54534
54535   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54536   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54537   {
54538     try {
54539       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54540     } catch (std::out_of_range& e) {
54541       {
54542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54543       };
54544     } catch (std::exception& e) {
54545       {
54546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54547       };
54548     } catch (Dali::DaliException e) {
54549       {
54550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54551       };
54552     } catch (...) {
54553       {
54554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54555       };
54556     }
54557   }
54558
54559 }
54560
54561
54562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54563   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54564   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54565
54566   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54567   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54568   {
54569     try {
54570       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54571     } catch (std::out_of_range& e) {
54572       {
54573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54574       };
54575     } catch (std::exception& e) {
54576       {
54577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54578       };
54579     } catch (Dali::DaliException e) {
54580       {
54581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54582       };
54583     } catch (...) {
54584       {
54585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54586       };
54587     }
54588   }
54589
54590 }
54591
54592
54593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54594   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54595   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54596
54597   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54598   arg2 = (Dali::RefObject *)jarg2;
54599   {
54600     try {
54601       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54602     } catch (std::out_of_range& e) {
54603       {
54604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54605       };
54606     } catch (std::exception& e) {
54607       {
54608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54609       };
54610     } catch (Dali::DaliException e) {
54611       {
54612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54613       };
54614     } catch (...) {
54615       {
54616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54617       };
54618     }
54619   }
54620
54621 }
54622
54623
54624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54625   void * jresult ;
54626   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54627
54628   {
54629     try {
54630       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54631     } catch (std::out_of_range& e) {
54632       {
54633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54634       };
54635     } catch (std::exception& e) {
54636       {
54637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54638       };
54639     } catch (Dali::DaliException e) {
54640       {
54641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54642       };
54643     } catch (...) {
54644       {
54645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54646       };
54647     }
54648   }
54649
54650   jresult = (void *)result;
54651   return jresult;
54652 }
54653
54654
54655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54656   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54657
54658   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54659   {
54660     try {
54661       delete arg1;
54662     } catch (std::out_of_range& e) {
54663       {
54664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54665       };
54666     } catch (std::exception& e) {
54667       {
54668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54669       };
54670     } catch (Dali::DaliException e) {
54671       {
54672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54673       };
54674     } catch (...) {
54675       {
54676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54677       };
54678     }
54679   }
54680
54681 }
54682
54683
54684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54685   unsigned int jresult ;
54686   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54687   bool result;
54688
54689   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54690   {
54691     try {
54692       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54693     } catch (std::out_of_range& e) {
54694       {
54695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54696       };
54697     } catch (std::exception& e) {
54698       {
54699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54700       };
54701     } catch (Dali::DaliException e) {
54702       {
54703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54704       };
54705     } catch (...) {
54706       {
54707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54708       };
54709     }
54710   }
54711
54712   jresult = result;
54713   return jresult;
54714 }
54715
54716
54717 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54718   unsigned long jresult ;
54719   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54720   std::size_t result;
54721
54722   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54723   {
54724     try {
54725       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54726     } catch (std::out_of_range& e) {
54727       {
54728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54729       };
54730     } catch (std::exception& e) {
54731       {
54732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54733       };
54734     } catch (Dali::DaliException e) {
54735       {
54736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54737       };
54738     } catch (...) {
54739       {
54740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54741       };
54742     }
54743   }
54744
54745   jresult = (unsigned long)result;
54746   return jresult;
54747 }
54748
54749
54750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54751   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54752   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54753
54754   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54755   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54756   {
54757     try {
54758       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54759     } catch (std::out_of_range& e) {
54760       {
54761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54762       };
54763     } catch (std::exception& e) {
54764       {
54765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54766       };
54767     } catch (Dali::DaliException e) {
54768       {
54769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54770       };
54771     } catch (...) {
54772       {
54773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54774       };
54775     }
54776   }
54777
54778 }
54779
54780
54781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54782   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54783   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54784
54785   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54786   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54787   {
54788     try {
54789       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54790     } catch (std::out_of_range& e) {
54791       {
54792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54793       };
54794     } catch (std::exception& e) {
54795       {
54796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54797       };
54798     } catch (Dali::DaliException e) {
54799       {
54800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54801       };
54802     } catch (...) {
54803       {
54804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54805       };
54806     }
54807   }
54808
54809 }
54810
54811
54812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54813   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54814   Dali::PropertyNotification *arg2 = 0 ;
54815
54816   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54817   arg2 = (Dali::PropertyNotification *)jarg2;
54818   if (!arg2) {
54819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54820     return ;
54821   }
54822   {
54823     try {
54824       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54825     } catch (std::out_of_range& e) {
54826       {
54827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54828       };
54829     } catch (std::exception& e) {
54830       {
54831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54832       };
54833     } catch (Dali::DaliException e) {
54834       {
54835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54836       };
54837     } catch (...) {
54838       {
54839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54840       };
54841     }
54842   }
54843
54844 }
54845
54846
54847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54848   void * jresult ;
54849   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54850
54851   {
54852     try {
54853       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54854     } catch (std::out_of_range& e) {
54855       {
54856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54857       };
54858     } catch (std::exception& e) {
54859       {
54860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54861       };
54862     } catch (Dali::DaliException e) {
54863       {
54864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54865       };
54866     } catch (...) {
54867       {
54868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54869       };
54870     }
54871   }
54872
54873   jresult = (void *)result;
54874   return jresult;
54875 }
54876
54877
54878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54879   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54880
54881   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54882   {
54883     try {
54884       delete arg1;
54885     } catch (std::out_of_range& e) {
54886       {
54887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54888       };
54889     } catch (std::exception& e) {
54890       {
54891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54892       };
54893     } catch (Dali::DaliException e) {
54894       {
54895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54896       };
54897     } catch (...) {
54898       {
54899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54900       };
54901     }
54902   }
54903
54904 }
54905
54906
54907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54908   unsigned int jresult ;
54909   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54910   bool result;
54911
54912   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54913   {
54914     try {
54915       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54916     } catch (std::out_of_range& e) {
54917       {
54918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54919       };
54920     } catch (std::exception& e) {
54921       {
54922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54923       };
54924     } catch (Dali::DaliException e) {
54925       {
54926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54927       };
54928     } catch (...) {
54929       {
54930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54931       };
54932     }
54933   }
54934
54935   jresult = result;
54936   return jresult;
54937 }
54938
54939
54940 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54941   unsigned long jresult ;
54942   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54943   std::size_t result;
54944
54945   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54946   {
54947     try {
54948       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54949     } catch (std::out_of_range& e) {
54950       {
54951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54952       };
54953     } catch (std::exception& e) {
54954       {
54955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54956       };
54957     } catch (Dali::DaliException e) {
54958       {
54959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54960       };
54961     } catch (...) {
54962       {
54963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54964       };
54965     }
54966   }
54967
54968   jresult = (unsigned long)result;
54969   return jresult;
54970 }
54971
54972
54973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54974   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54975   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54976
54977   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54978   arg2 = (void (*)(Dali::Image))jarg2;
54979   {
54980     try {
54981       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54982     } catch (std::out_of_range& e) {
54983       {
54984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54985       };
54986     } catch (std::exception& e) {
54987       {
54988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54989       };
54990     } catch (Dali::DaliException e) {
54991       {
54992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54993       };
54994     } catch (...) {
54995       {
54996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54997       };
54998     }
54999   }
55000
55001 }
55002
55003
55004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
55005   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55006   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
55007
55008   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55009   arg2 = (void (*)(Dali::Image))jarg2;
55010   {
55011     try {
55012       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
55013     } catch (std::out_of_range& e) {
55014       {
55015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55016       };
55017     } catch (std::exception& e) {
55018       {
55019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55020       };
55021     } catch (Dali::DaliException e) {
55022       {
55023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55024       };
55025     } catch (...) {
55026       {
55027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55028       };
55029     }
55030   }
55031
55032 }
55033
55034
55035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
55036   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55037   Dali::Image arg2 ;
55038   Dali::Image *argp2 ;
55039
55040   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55041   argp2 = (Dali::Image *)jarg2;
55042   if (!argp2) {
55043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
55044     return ;
55045   }
55046   arg2 = *argp2;
55047   {
55048     try {
55049       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
55050     } catch (std::out_of_range& e) {
55051       {
55052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55053       };
55054     } catch (std::exception& e) {
55055       {
55056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55057       };
55058     } catch (Dali::DaliException e) {
55059       {
55060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55061       };
55062     } catch (...) {
55063       {
55064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55065       };
55066     }
55067   }
55068
55069 }
55070
55071
55072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
55073   void * jresult ;
55074   Dali::Signal< void (Dali::Image) > *result = 0 ;
55075
55076   {
55077     try {
55078       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
55079     } catch (std::out_of_range& e) {
55080       {
55081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55082       };
55083     } catch (std::exception& e) {
55084       {
55085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55086       };
55087     } catch (Dali::DaliException e) {
55088       {
55089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55090       };
55091     } catch (...) {
55092       {
55093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55094       };
55095     }
55096   }
55097
55098   jresult = (void *)result;
55099   return jresult;
55100 }
55101
55102
55103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
55104   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55105
55106   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55107   {
55108     try {
55109       delete arg1;
55110     } catch (std::out_of_range& e) {
55111       {
55112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55113       };
55114     } catch (std::exception& e) {
55115       {
55116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55117       };
55118     } catch (Dali::DaliException e) {
55119       {
55120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55121       };
55122     } catch (...) {
55123       {
55124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55125       };
55126     }
55127   }
55128
55129 }
55130
55131
55132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55133   void * jresult ;
55134   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55135
55136   {
55137     try {
55138       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55139     } catch (std::out_of_range& e) {
55140       {
55141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55142       };
55143     } catch (std::exception& e) {
55144       {
55145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55146       };
55147     } catch (Dali::DaliException e) {
55148       {
55149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55150       };
55151     } catch (...) {
55152       {
55153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55154       };
55155     }
55156   }
55157
55158   jresult = (void *)result;
55159   return jresult;
55160 }
55161
55162
55163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55164   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55165
55166   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55167   {
55168     try {
55169       delete arg1;
55170     } catch (std::out_of_range& e) {
55171       {
55172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55173       };
55174     } catch (std::exception& e) {
55175       {
55176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55177       };
55178     } catch (Dali::DaliException e) {
55179       {
55180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55181       };
55182     } catch (...) {
55183       {
55184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55185       };
55186     }
55187   }
55188
55189 }
55190
55191
55192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55193   unsigned int jresult ;
55194   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55195   bool result;
55196
55197   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55198   {
55199     try {
55200       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);
55201     } catch (std::out_of_range& e) {
55202       {
55203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55204       };
55205     } catch (std::exception& e) {
55206       {
55207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55208       };
55209     } catch (Dali::DaliException e) {
55210       {
55211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55212       };
55213     } catch (...) {
55214       {
55215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55216       };
55217     }
55218   }
55219
55220   jresult = result;
55221   return jresult;
55222 }
55223
55224
55225 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55226   unsigned long jresult ;
55227   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55228   std::size_t result;
55229
55230   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55231   {
55232     try {
55233       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);
55234     } catch (std::out_of_range& e) {
55235       {
55236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55237       };
55238     } catch (std::exception& e) {
55239       {
55240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55241       };
55242     } catch (Dali::DaliException e) {
55243       {
55244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55245       };
55246     } catch (...) {
55247       {
55248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55249       };
55250     }
55251   }
55252
55253   jresult = (unsigned long)result;
55254   return jresult;
55255 }
55256
55257
55258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55259   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55260   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55261
55262   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55263   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55264   {
55265     try {
55266       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55267     } catch (std::out_of_range& e) {
55268       {
55269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55270       };
55271     } catch (std::exception& e) {
55272       {
55273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55274       };
55275     } catch (Dali::DaliException e) {
55276       {
55277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55278       };
55279     } catch (...) {
55280       {
55281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55282       };
55283     }
55284   }
55285
55286 }
55287
55288
55289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55290   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55291   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55292
55293   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55294   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55295   {
55296     try {
55297       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55298     } catch (std::out_of_range& e) {
55299       {
55300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55301       };
55302     } catch (std::exception& e) {
55303       {
55304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55305       };
55306     } catch (Dali::DaliException e) {
55307       {
55308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55309       };
55310     } catch (...) {
55311       {
55312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55313       };
55314     }
55315   }
55316
55317 }
55318
55319
55320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55321   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55322   Dali::Actor arg2 ;
55323   Dali::LongPressGesture *arg3 = 0 ;
55324   Dali::Actor *argp2 ;
55325
55326   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55327   argp2 = (Dali::Actor *)jarg2;
55328   if (!argp2) {
55329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55330     return ;
55331   }
55332   arg2 = *argp2;
55333   arg3 = (Dali::LongPressGesture *)jarg3;
55334   if (!arg3) {
55335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55336     return ;
55337   }
55338   {
55339     try {
55340       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55341     } catch (std::out_of_range& e) {
55342       {
55343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55344       };
55345     } catch (std::exception& e) {
55346       {
55347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55348       };
55349     } catch (Dali::DaliException e) {
55350       {
55351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55352       };
55353     } catch (...) {
55354       {
55355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55356       };
55357     }
55358   }
55359
55360 }
55361
55362
55363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55364   void * jresult ;
55365   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55366
55367   {
55368     try {
55369       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55370     } catch (std::out_of_range& e) {
55371       {
55372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55373       };
55374     } catch (std::exception& e) {
55375       {
55376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55377       };
55378     } catch (Dali::DaliException e) {
55379       {
55380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55381       };
55382     } catch (...) {
55383       {
55384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55385       };
55386     }
55387   }
55388
55389   jresult = (void *)result;
55390   return jresult;
55391 }
55392
55393
55394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55395   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55396
55397   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55398   {
55399     try {
55400       delete arg1;
55401     } catch (std::out_of_range& e) {
55402       {
55403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55404       };
55405     } catch (std::exception& e) {
55406       {
55407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55408       };
55409     } catch (Dali::DaliException e) {
55410       {
55411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55412       };
55413     } catch (...) {
55414       {
55415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55416       };
55417     }
55418   }
55419
55420 }
55421
55422
55423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55424   unsigned int jresult ;
55425   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55426   bool result;
55427
55428   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55429   {
55430     try {
55431       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);
55432     } catch (std::out_of_range& e) {
55433       {
55434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55435       };
55436     } catch (std::exception& e) {
55437       {
55438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55439       };
55440     } catch (Dali::DaliException e) {
55441       {
55442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55443       };
55444     } catch (...) {
55445       {
55446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55447       };
55448     }
55449   }
55450
55451   jresult = result;
55452   return jresult;
55453 }
55454
55455
55456 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55457   unsigned long jresult ;
55458   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55459   std::size_t result;
55460
55461   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55462   {
55463     try {
55464       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);
55465     } catch (std::out_of_range& e) {
55466       {
55467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55468       };
55469     } catch (std::exception& e) {
55470       {
55471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55472       };
55473     } catch (Dali::DaliException e) {
55474       {
55475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55476       };
55477     } catch (...) {
55478       {
55479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55480       };
55481     }
55482   }
55483
55484   jresult = (unsigned long)result;
55485   return jresult;
55486 }
55487
55488
55489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55490   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55491   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55492
55493   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55494   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55495   {
55496     try {
55497       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55498     } catch (std::out_of_range& e) {
55499       {
55500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55501       };
55502     } catch (std::exception& e) {
55503       {
55504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55505       };
55506     } catch (Dali::DaliException e) {
55507       {
55508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55509       };
55510     } catch (...) {
55511       {
55512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55513       };
55514     }
55515   }
55516
55517 }
55518
55519
55520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55521   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55522   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55523
55524   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55525   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55526   {
55527     try {
55528       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55529     } catch (std::out_of_range& e) {
55530       {
55531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55532       };
55533     } catch (std::exception& e) {
55534       {
55535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55536       };
55537     } catch (Dali::DaliException e) {
55538       {
55539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55540       };
55541     } catch (...) {
55542       {
55543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55544       };
55545     }
55546   }
55547
55548 }
55549
55550
55551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55552   unsigned int jresult ;
55553   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55554   Dali::Actor arg2 ;
55555   Dali::TouchData *arg3 = 0 ;
55556   Dali::Actor *argp2 ;
55557   bool result;
55558
55559   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55560   argp2 = (Dali::Actor *)jarg2;
55561   if (!argp2) {
55562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55563     return 0;
55564   }
55565   arg2 = *argp2;
55566   arg3 = (Dali::TouchData *)jarg3;
55567   if (!arg3) {
55568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55569     return 0;
55570   }
55571   {
55572     try {
55573       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55574     } catch (std::out_of_range& e) {
55575       {
55576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55577       };
55578     } catch (std::exception& e) {
55579       {
55580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55581       };
55582     } catch (Dali::DaliException e) {
55583       {
55584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55585       };
55586     } catch (...) {
55587       {
55588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55589       };
55590     }
55591   }
55592
55593   jresult = result;
55594   return jresult;
55595 }
55596
55597
55598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55599   void * jresult ;
55600   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55601
55602   {
55603     try {
55604       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55605     } catch (std::out_of_range& e) {
55606       {
55607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55608       };
55609     } catch (std::exception& e) {
55610       {
55611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55612       };
55613     } catch (Dali::DaliException e) {
55614       {
55615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55616       };
55617     } catch (...) {
55618       {
55619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55620       };
55621     }
55622   }
55623
55624   jresult = (void *)result;
55625   return jresult;
55626 }
55627
55628
55629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55630   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55631
55632   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55633   {
55634     try {
55635       delete arg1;
55636     } catch (std::out_of_range& e) {
55637       {
55638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55639       };
55640     } catch (std::exception& e) {
55641       {
55642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55643       };
55644     } catch (Dali::DaliException e) {
55645       {
55646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55647       };
55648     } catch (...) {
55649       {
55650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55651       };
55652     }
55653   }
55654
55655 }
55656
55657
55658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55659   unsigned int jresult ;
55660   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55661   bool result;
55662
55663   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55664   {
55665     try {
55666       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);
55667     } catch (std::out_of_range& e) {
55668       {
55669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55670       };
55671     } catch (std::exception& e) {
55672       {
55673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55674       };
55675     } catch (Dali::DaliException e) {
55676       {
55677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55678       };
55679     } catch (...) {
55680       {
55681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55682       };
55683     }
55684   }
55685
55686   jresult = result;
55687   return jresult;
55688 }
55689
55690
55691 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55692   unsigned long jresult ;
55693   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55694   std::size_t result;
55695
55696   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55697   {
55698     try {
55699       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);
55700     } catch (std::out_of_range& e) {
55701       {
55702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55703       };
55704     } catch (std::exception& e) {
55705       {
55706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55707       };
55708     } catch (Dali::DaliException e) {
55709       {
55710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55711       };
55712     } catch (...) {
55713       {
55714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55715       };
55716     }
55717   }
55718
55719   jresult = (unsigned long)result;
55720   return jresult;
55721 }
55722
55723
55724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55725   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55726   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55727
55728   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55729   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55730   {
55731     try {
55732       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55733     } catch (std::out_of_range& e) {
55734       {
55735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55736       };
55737     } catch (std::exception& e) {
55738       {
55739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55740       };
55741     } catch (Dali::DaliException e) {
55742       {
55743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55744       };
55745     } catch (...) {
55746       {
55747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55748       };
55749     }
55750   }
55751
55752 }
55753
55754
55755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55756   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55757   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55758
55759   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55760   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55761   {
55762     try {
55763       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55764     } catch (std::out_of_range& e) {
55765       {
55766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55767       };
55768     } catch (std::exception& e) {
55769       {
55770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55771       };
55772     } catch (Dali::DaliException e) {
55773       {
55774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55775       };
55776     } catch (...) {
55777       {
55778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55779       };
55780     }
55781   }
55782
55783 }
55784
55785
55786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55787   unsigned int jresult ;
55788   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55789   Dali::Actor arg2 ;
55790   Dali::HoverEvent *arg3 = 0 ;
55791   Dali::Actor *argp2 ;
55792   bool result;
55793
55794   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55795   argp2 = (Dali::Actor *)jarg2;
55796   if (!argp2) {
55797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55798     return 0;
55799   }
55800   arg2 = *argp2;
55801   arg3 = (Dali::HoverEvent *)jarg3;
55802   if (!arg3) {
55803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55804     return 0;
55805   }
55806   {
55807     try {
55808       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55809     } catch (std::out_of_range& e) {
55810       {
55811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55812       };
55813     } catch (std::exception& e) {
55814       {
55815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55816       };
55817     } catch (Dali::DaliException e) {
55818       {
55819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55820       };
55821     } catch (...) {
55822       {
55823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55824       };
55825     }
55826   }
55827
55828   jresult = result;
55829   return jresult;
55830 }
55831
55832
55833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55834   void * jresult ;
55835   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55836
55837   {
55838     try {
55839       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55840     } catch (std::out_of_range& e) {
55841       {
55842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55843       };
55844     } catch (std::exception& e) {
55845       {
55846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55847       };
55848     } catch (Dali::DaliException e) {
55849       {
55850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55851       };
55852     } catch (...) {
55853       {
55854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55855       };
55856     }
55857   }
55858
55859   jresult = (void *)result;
55860   return jresult;
55861 }
55862
55863
55864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55865   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55866
55867   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55868   {
55869     try {
55870       delete arg1;
55871     } catch (std::out_of_range& e) {
55872       {
55873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55874       };
55875     } catch (std::exception& e) {
55876       {
55877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55878       };
55879     } catch (Dali::DaliException e) {
55880       {
55881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55882       };
55883     } catch (...) {
55884       {
55885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55886       };
55887     }
55888   }
55889
55890 }
55891
55892
55893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55894   unsigned int jresult ;
55895   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55896   bool result;
55897
55898   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55899   {
55900     try {
55901       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);
55902     } catch (std::out_of_range& e) {
55903       {
55904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55905       };
55906     } catch (std::exception& e) {
55907       {
55908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55909       };
55910     } catch (Dali::DaliException e) {
55911       {
55912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55913       };
55914     } catch (...) {
55915       {
55916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55917       };
55918     }
55919   }
55920
55921   jresult = result;
55922   return jresult;
55923 }
55924
55925
55926 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55927   unsigned long jresult ;
55928   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55929   std::size_t result;
55930
55931   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55932   {
55933     try {
55934       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);
55935     } catch (std::out_of_range& e) {
55936       {
55937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55938       };
55939     } catch (std::exception& e) {
55940       {
55941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55942       };
55943     } catch (Dali::DaliException e) {
55944       {
55945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55946       };
55947     } catch (...) {
55948       {
55949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55950       };
55951     }
55952   }
55953
55954   jresult = (unsigned long)result;
55955   return jresult;
55956 }
55957
55958
55959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55960   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55961   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55962
55963   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55964   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55965   {
55966     try {
55967       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55968     } catch (std::out_of_range& e) {
55969       {
55970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55971       };
55972     } catch (std::exception& e) {
55973       {
55974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55975       };
55976     } catch (Dali::DaliException e) {
55977       {
55978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55979       };
55980     } catch (...) {
55981       {
55982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55983       };
55984     }
55985   }
55986
55987 }
55988
55989
55990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55991   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55992   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55993
55994   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55995   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55996   {
55997     try {
55998       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55999     } catch (std::out_of_range& e) {
56000       {
56001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56002       };
56003     } catch (std::exception& e) {
56004       {
56005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56006       };
56007     } catch (Dali::DaliException e) {
56008       {
56009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56010       };
56011     } catch (...) {
56012       {
56013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56014       };
56015     }
56016   }
56017
56018 }
56019
56020
56021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56022   unsigned int jresult ;
56023   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56024   Dali::Actor arg2 ;
56025   Dali::WheelEvent *arg3 = 0 ;
56026   Dali::Actor *argp2 ;
56027   bool result;
56028
56029   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56030   argp2 = (Dali::Actor *)jarg2;
56031   if (!argp2) {
56032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56033     return 0;
56034   }
56035   arg2 = *argp2;
56036   arg3 = (Dali::WheelEvent *)jarg3;
56037   if (!arg3) {
56038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56039     return 0;
56040   }
56041   {
56042     try {
56043       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
56044     } catch (std::out_of_range& e) {
56045       {
56046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56047       };
56048     } catch (std::exception& e) {
56049       {
56050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56051       };
56052     } catch (Dali::DaliException e) {
56053       {
56054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56055       };
56056     } catch (...) {
56057       {
56058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56059       };
56060     }
56061   }
56062
56063   jresult = result;
56064   return jresult;
56065 }
56066
56067
56068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
56069   void * jresult ;
56070   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
56071
56072   {
56073     try {
56074       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
56075     } catch (std::out_of_range& e) {
56076       {
56077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56078       };
56079     } catch (std::exception& e) {
56080       {
56081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56082       };
56083     } catch (Dali::DaliException e) {
56084       {
56085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56086       };
56087     } catch (...) {
56088       {
56089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56090       };
56091     }
56092   }
56093
56094   jresult = (void *)result;
56095   return jresult;
56096 }
56097
56098
56099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
56100   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56101
56102   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56103   {
56104     try {
56105       delete arg1;
56106     } catch (std::out_of_range& e) {
56107       {
56108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56109       };
56110     } catch (std::exception& e) {
56111       {
56112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56113       };
56114     } catch (Dali::DaliException e) {
56115       {
56116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56117       };
56118     } catch (...) {
56119       {
56120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56121       };
56122     }
56123   }
56124
56125 }
56126
56127
56128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56129   unsigned int jresult ;
56130   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56131   bool result;
56132
56133   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56134   {
56135     try {
56136       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56137     } catch (std::out_of_range& e) {
56138       {
56139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56140       };
56141     } catch (std::exception& e) {
56142       {
56143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56144       };
56145     } catch (Dali::DaliException e) {
56146       {
56147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56148       };
56149     } catch (...) {
56150       {
56151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56152       };
56153     }
56154   }
56155
56156   jresult = result;
56157   return jresult;
56158 }
56159
56160
56161 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56162   unsigned long jresult ;
56163   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56164   std::size_t result;
56165
56166   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56167   {
56168     try {
56169       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56170     } catch (std::out_of_range& e) {
56171       {
56172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56173       };
56174     } catch (std::exception& e) {
56175       {
56176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56177       };
56178     } catch (Dali::DaliException e) {
56179       {
56180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56181       };
56182     } catch (...) {
56183       {
56184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56185       };
56186     }
56187   }
56188
56189   jresult = (unsigned long)result;
56190   return jresult;
56191 }
56192
56193
56194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56195   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56196   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56197
56198   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56199   arg2 = (void (*)(Dali::Actor))jarg2;
56200   {
56201     try {
56202       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56203     } catch (std::out_of_range& e) {
56204       {
56205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56206       };
56207     } catch (std::exception& e) {
56208       {
56209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56210       };
56211     } catch (Dali::DaliException e) {
56212       {
56213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56214       };
56215     } catch (...) {
56216       {
56217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56218       };
56219     }
56220   }
56221
56222 }
56223
56224
56225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56226   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56227   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56228
56229   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56230   arg2 = (void (*)(Dali::Actor))jarg2;
56231   {
56232     try {
56233       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56234     } catch (std::out_of_range& e) {
56235       {
56236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56237       };
56238     } catch (std::exception& e) {
56239       {
56240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56241       };
56242     } catch (Dali::DaliException e) {
56243       {
56244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56245       };
56246     } catch (...) {
56247       {
56248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56249       };
56250     }
56251   }
56252
56253 }
56254
56255
56256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56257   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56258   Dali::Actor arg2 ;
56259   Dali::Actor *argp2 ;
56260
56261   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56262   argp2 = (Dali::Actor *)jarg2;
56263   if (!argp2) {
56264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56265     return ;
56266   }
56267   arg2 = *argp2;
56268   {
56269     try {
56270       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56271     } catch (std::out_of_range& e) {
56272       {
56273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56274       };
56275     } catch (std::exception& e) {
56276       {
56277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56278       };
56279     } catch (Dali::DaliException e) {
56280       {
56281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56282       };
56283     } catch (...) {
56284       {
56285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56286       };
56287     }
56288   }
56289
56290 }
56291
56292
56293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56294   void * jresult ;
56295   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56296
56297   {
56298     try {
56299       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56300     } catch (std::out_of_range& e) {
56301       {
56302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56303       };
56304     } catch (std::exception& e) {
56305       {
56306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56307       };
56308     } catch (Dali::DaliException e) {
56309       {
56310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56311       };
56312     } catch (...) {
56313       {
56314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56315       };
56316     }
56317   }
56318
56319   jresult = (void *)result;
56320   return jresult;
56321 }
56322
56323
56324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56325   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56326
56327   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56328   {
56329     try {
56330       delete arg1;
56331     } catch (std::out_of_range& e) {
56332       {
56333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56334       };
56335     } catch (std::exception& e) {
56336       {
56337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56338       };
56339     } catch (Dali::DaliException e) {
56340       {
56341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56342       };
56343     } catch (...) {
56344       {
56345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56346       };
56347     }
56348   }
56349
56350 }
56351
56352
56353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56354   unsigned int jresult ;
56355   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56356   bool result;
56357
56358   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56359   {
56360     try {
56361       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56362     } catch (std::out_of_range& e) {
56363       {
56364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56365       };
56366     } catch (std::exception& e) {
56367       {
56368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56369       };
56370     } catch (Dali::DaliException e) {
56371       {
56372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56373       };
56374     } catch (...) {
56375       {
56376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56377       };
56378     }
56379   }
56380
56381   jresult = result;
56382   return jresult;
56383 }
56384
56385
56386 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56387   unsigned long jresult ;
56388   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56389   std::size_t result;
56390
56391   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56392   {
56393     try {
56394       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56395     } catch (std::out_of_range& e) {
56396       {
56397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56398       };
56399     } catch (std::exception& e) {
56400       {
56401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56402       };
56403     } catch (Dali::DaliException e) {
56404       {
56405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56406       };
56407     } catch (...) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56410       };
56411     }
56412   }
56413
56414   jresult = (unsigned long)result;
56415   return jresult;
56416 }
56417
56418
56419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56420   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56421   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56422
56423   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56424   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56425   {
56426     try {
56427       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56428     } catch (std::out_of_range& e) {
56429       {
56430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56431       };
56432     } catch (std::exception& e) {
56433       {
56434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56435       };
56436     } catch (Dali::DaliException e) {
56437       {
56438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56439       };
56440     } catch (...) {
56441       {
56442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56443       };
56444     }
56445   }
56446
56447 }
56448
56449
56450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56451   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56452   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56453
56454   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56455   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56456   {
56457     try {
56458       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56459     } catch (std::out_of_range& e) {
56460       {
56461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56462       };
56463     } catch (std::exception& e) {
56464       {
56465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56466       };
56467     } catch (Dali::DaliException e) {
56468       {
56469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56470       };
56471     } catch (...) {
56472       {
56473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56474       };
56475     }
56476   }
56477
56478 }
56479
56480
56481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56482   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56483   Dali::KeyEvent *arg2 = 0 ;
56484
56485   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56486   arg2 = (Dali::KeyEvent *)jarg2;
56487   if (!arg2) {
56488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56489     return ;
56490   }
56491   {
56492     try {
56493       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56494     } catch (std::out_of_range& e) {
56495       {
56496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56497       };
56498     } catch (std::exception& e) {
56499       {
56500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56501       };
56502     } catch (Dali::DaliException e) {
56503       {
56504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56505       };
56506     } catch (...) {
56507       {
56508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56509       };
56510     }
56511   }
56512
56513 }
56514
56515
56516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56517   void * jresult ;
56518   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56519
56520   {
56521     try {
56522       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56523     } catch (std::out_of_range& e) {
56524       {
56525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56526       };
56527     } catch (std::exception& e) {
56528       {
56529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56530       };
56531     } catch (Dali::DaliException e) {
56532       {
56533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56534       };
56535     } catch (...) {
56536       {
56537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56538       };
56539     }
56540   }
56541
56542   jresult = (void *)result;
56543   return jresult;
56544 }
56545
56546
56547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56548   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56549
56550   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56551   {
56552     try {
56553       delete arg1;
56554     } catch (std::out_of_range& e) {
56555       {
56556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56557       };
56558     } catch (std::exception& e) {
56559       {
56560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56561       };
56562     } catch (Dali::DaliException e) {
56563       {
56564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56565       };
56566     } catch (...) {
56567       {
56568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56569       };
56570     }
56571   }
56572
56573 }
56574
56575
56576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56577   unsigned int jresult ;
56578   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56579   bool result;
56580
56581   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56582   {
56583     try {
56584       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56585     } catch (std::out_of_range& e) {
56586       {
56587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56588       };
56589     } catch (std::exception& e) {
56590       {
56591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56592       };
56593     } catch (Dali::DaliException e) {
56594       {
56595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56596       };
56597     } catch (...) {
56598       {
56599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56600       };
56601     }
56602   }
56603
56604   jresult = result;
56605   return jresult;
56606 }
56607
56608
56609 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56610   unsigned long jresult ;
56611   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56612   std::size_t result;
56613
56614   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56615   {
56616     try {
56617       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56618     } catch (std::out_of_range& e) {
56619       {
56620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56621       };
56622     } catch (std::exception& e) {
56623       {
56624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56625       };
56626     } catch (Dali::DaliException e) {
56627       {
56628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56629       };
56630     } catch (...) {
56631       {
56632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56633       };
56634     }
56635   }
56636
56637   jresult = (unsigned long)result;
56638   return jresult;
56639 }
56640
56641
56642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56643   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56644   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56645
56646   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56647   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56648   {
56649     try {
56650       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56651     } catch (std::out_of_range& e) {
56652       {
56653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56654       };
56655     } catch (std::exception& e) {
56656       {
56657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56658       };
56659     } catch (Dali::DaliException e) {
56660       {
56661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56662       };
56663     } catch (...) {
56664       {
56665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56666       };
56667     }
56668   }
56669
56670 }
56671
56672
56673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56674   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56675   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56676
56677   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56678   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56679   {
56680     try {
56681       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56682     } catch (std::out_of_range& e) {
56683       {
56684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56685       };
56686     } catch (std::exception& e) {
56687       {
56688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56689       };
56690     } catch (Dali::DaliException e) {
56691       {
56692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56693       };
56694     } catch (...) {
56695       {
56696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56697       };
56698     }
56699   }
56700
56701 }
56702
56703
56704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56705   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56706   Dali::TouchData *arg2 = 0 ;
56707
56708   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56709   arg2 = (Dali::TouchData *)jarg2;
56710   if (!arg2) {
56711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56712     return ;
56713   }
56714   {
56715     try {
56716       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56717     } catch (std::out_of_range& e) {
56718       {
56719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56720       };
56721     } catch (std::exception& e) {
56722       {
56723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56724       };
56725     } catch (Dali::DaliException e) {
56726       {
56727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56728       };
56729     } catch (...) {
56730       {
56731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56732       };
56733     }
56734   }
56735
56736 }
56737
56738
56739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56740   void * jresult ;
56741   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56742
56743   {
56744     try {
56745       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56746     } catch (std::out_of_range& e) {
56747       {
56748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56749       };
56750     } catch (std::exception& e) {
56751       {
56752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56753       };
56754     } catch (Dali::DaliException e) {
56755       {
56756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56757       };
56758     } catch (...) {
56759       {
56760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56761       };
56762     }
56763   }
56764
56765   jresult = (void *)result;
56766   return jresult;
56767 }
56768
56769
56770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56771   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56772
56773   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56774   {
56775     try {
56776       delete arg1;
56777     } catch (std::out_of_range& e) {
56778       {
56779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56780       };
56781     } catch (std::exception& e) {
56782       {
56783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56784       };
56785     } catch (Dali::DaliException e) {
56786       {
56787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56788       };
56789     } catch (...) {
56790       {
56791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56792       };
56793     }
56794   }
56795
56796 }
56797
56798
56799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56800   unsigned int jresult ;
56801   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56802   bool result;
56803
56804   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56805   {
56806     try {
56807       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56808     } catch (std::out_of_range& e) {
56809       {
56810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56811       };
56812     } catch (std::exception& e) {
56813       {
56814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56815       };
56816     } catch (Dali::DaliException e) {
56817       {
56818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56819       };
56820     } catch (...) {
56821       {
56822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56823       };
56824     }
56825   }
56826
56827   jresult = result;
56828   return jresult;
56829 }
56830
56831
56832 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56833   unsigned long jresult ;
56834   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56835   std::size_t result;
56836
56837   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56838   {
56839     try {
56840       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56841     } catch (std::out_of_range& e) {
56842       {
56843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56844       };
56845     } catch (std::exception& e) {
56846       {
56847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56848       };
56849     } catch (Dali::DaliException e) {
56850       {
56851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56852       };
56853     } catch (...) {
56854       {
56855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56856       };
56857     }
56858   }
56859
56860   jresult = (unsigned long)result;
56861   return jresult;
56862 }
56863
56864
56865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56866   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56867   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56868
56869   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56870   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56871   {
56872     try {
56873       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56874     } catch (std::out_of_range& e) {
56875       {
56876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56877       };
56878     } catch (std::exception& e) {
56879       {
56880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56881       };
56882     } catch (Dali::DaliException e) {
56883       {
56884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56885       };
56886     } catch (...) {
56887       {
56888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56889       };
56890     }
56891   }
56892
56893 }
56894
56895
56896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56897   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56898   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56899
56900   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56901   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56902   {
56903     try {
56904       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56905     } catch (std::out_of_range& e) {
56906       {
56907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56908       };
56909     } catch (std::exception& e) {
56910       {
56911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56912       };
56913     } catch (Dali::DaliException e) {
56914       {
56915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56916       };
56917     } catch (...) {
56918       {
56919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56920       };
56921     }
56922   }
56923
56924 }
56925
56926
56927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56928   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56929   Dali::WheelEvent *arg2 = 0 ;
56930
56931   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56932   arg2 = (Dali::WheelEvent *)jarg2;
56933   if (!arg2) {
56934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56935     return ;
56936   }
56937   {
56938     try {
56939       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56940     } catch (std::out_of_range& e) {
56941       {
56942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56943       };
56944     } catch (std::exception& e) {
56945       {
56946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56947       };
56948     } catch (Dali::DaliException e) {
56949       {
56950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56951       };
56952     } catch (...) {
56953       {
56954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56955       };
56956     }
56957   }
56958
56959 }
56960
56961
56962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56963   void * jresult ;
56964   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56965
56966   {
56967     try {
56968       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56969     } catch (std::out_of_range& e) {
56970       {
56971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56972       };
56973     } catch (std::exception& e) {
56974       {
56975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56976       };
56977     } catch (Dali::DaliException e) {
56978       {
56979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56980       };
56981     } catch (...) {
56982       {
56983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56984       };
56985     }
56986   }
56987
56988   jresult = (void *)result;
56989   return jresult;
56990 }
56991
56992
56993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56994   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56995
56996   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56997   {
56998     try {
56999       delete arg1;
57000     } catch (std::out_of_range& e) {
57001       {
57002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57003       };
57004     } catch (std::exception& e) {
57005       {
57006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57007       };
57008     } catch (Dali::DaliException e) {
57009       {
57010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57011       };
57012     } catch (...) {
57013       {
57014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57015       };
57016     }
57017   }
57018
57019 }
57020
57021
57022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
57023   void * jresult ;
57024   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57025
57026   {
57027     try {
57028       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
57029     } catch (std::out_of_range& e) {
57030       {
57031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57032       };
57033     } catch (std::exception& e) {
57034       {
57035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57036       };
57037     } catch (Dali::DaliException e) {
57038       {
57039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57040       };
57041     } catch (...) {
57042       {
57043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57044       };
57045     }
57046   }
57047
57048   jresult = (void *)result;
57049   return jresult;
57050 }
57051
57052
57053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
57054   void * jresult ;
57055   Dali::Radian arg1 ;
57056   Dali::Radian arg2 ;
57057   Dali::Radian *argp1 ;
57058   Dali::Radian *argp2 ;
57059   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57060
57061   argp1 = (Dali::Radian *)jarg1;
57062   if (!argp1) {
57063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
57064     return 0;
57065   }
57066   arg1 = *argp1;
57067   argp2 = (Dali::Radian *)jarg2;
57068   if (!argp2) {
57069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
57070     return 0;
57071   }
57072   arg2 = *argp2;
57073   {
57074     try {
57075       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
57076     } catch (std::out_of_range& e) {
57077       {
57078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57079       };
57080     } catch (std::exception& e) {
57081       {
57082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57083       };
57084     } catch (Dali::DaliException e) {
57085       {
57086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57087       };
57088     } catch (...) {
57089       {
57090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57091       };
57092     }
57093   }
57094
57095   jresult = (void *)result;
57096   return jresult;
57097 }
57098
57099
57100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
57101   void * jresult ;
57102   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
57103   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57104
57105   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57106   if (!arg1) {
57107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
57108     return 0;
57109   }
57110   {
57111     try {
57112       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
57113     } catch (std::out_of_range& e) {
57114       {
57115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57116       };
57117     } catch (std::exception& e) {
57118       {
57119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57120       };
57121     } catch (Dali::DaliException e) {
57122       {
57123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57124       };
57125     } catch (...) {
57126       {
57127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57128       };
57129     }
57130   }
57131
57132   jresult = (void *)result;
57133   return jresult;
57134 }
57135
57136
57137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57138   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57139   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57140
57141   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57142   arg2 = (Dali::Radian *)jarg2;
57143   if (arg1) (arg1)->first = *arg2;
57144 }
57145
57146
57147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57148   void * jresult ;
57149   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57150   Dali::Radian *result = 0 ;
57151
57152   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57153   result = (Dali::Radian *)& ((arg1)->first);
57154   jresult = (void *)result;
57155   return jresult;
57156 }
57157
57158
57159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57160   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57161   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57162
57163   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57164   arg2 = (Dali::Radian *)jarg2;
57165   if (arg1) (arg1)->second = *arg2;
57166 }
57167
57168
57169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57170   void * jresult ;
57171   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57172   Dali::Radian *result = 0 ;
57173
57174   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57175   result = (Dali::Radian *)& ((arg1)->second);
57176   jresult = (void *)result;
57177   return jresult;
57178 }
57179
57180
57181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57182   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57183
57184   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57185   {
57186     try {
57187       delete arg1;
57188     } catch (std::out_of_range& e) {
57189       {
57190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57191       };
57192     } catch (std::exception& e) {
57193       {
57194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57195       };
57196     } catch (Dali::DaliException e) {
57197       {
57198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57199       };
57200     } catch (...) {
57201       {
57202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57203       };
57204     }
57205   }
57206
57207 }
57208
57209
57210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57211   unsigned int jresult ;
57212   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57213   bool result;
57214
57215   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57216   {
57217     try {
57218       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);
57219     } catch (std::out_of_range& e) {
57220       {
57221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57222       };
57223     } catch (std::exception& e) {
57224       {
57225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57226       };
57227     } catch (Dali::DaliException e) {
57228       {
57229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57230       };
57231     } catch (...) {
57232       {
57233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57234       };
57235     }
57236   }
57237
57238   jresult = result;
57239   return jresult;
57240 }
57241
57242
57243 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57244   unsigned long jresult ;
57245   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57246   std::size_t result;
57247
57248   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57249   {
57250     try {
57251       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);
57252     } catch (std::out_of_range& e) {
57253       {
57254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57255       };
57256     } catch (std::exception& e) {
57257       {
57258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57259       };
57260     } catch (Dali::DaliException e) {
57261       {
57262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57263       };
57264     } catch (...) {
57265       {
57266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57267       };
57268     }
57269   }
57270
57271   jresult = (unsigned long)result;
57272   return jresult;
57273 }
57274
57275
57276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57277   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57278   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57279
57280   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57281   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57282   {
57283     try {
57284       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57285     } catch (std::out_of_range& e) {
57286       {
57287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57288       };
57289     } catch (std::exception& e) {
57290       {
57291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57292       };
57293     } catch (Dali::DaliException e) {
57294       {
57295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57296       };
57297     } catch (...) {
57298       {
57299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57300       };
57301     }
57302   }
57303
57304 }
57305
57306
57307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57308   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57309   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57310
57311   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57312   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57313   {
57314     try {
57315       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57316     } catch (std::out_of_range& e) {
57317       {
57318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57319       };
57320     } catch (std::exception& e) {
57321       {
57322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57323       };
57324     } catch (Dali::DaliException e) {
57325       {
57326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57327       };
57328     } catch (...) {
57329       {
57330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57331       };
57332     }
57333   }
57334
57335 }
57336
57337
57338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57339   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57340   Dali::Actor arg2 ;
57341   Dali::PanGesture *arg3 = 0 ;
57342   Dali::Actor *argp2 ;
57343
57344   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57345   argp2 = (Dali::Actor *)jarg2;
57346   if (!argp2) {
57347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57348     return ;
57349   }
57350   arg2 = *argp2;
57351   arg3 = (Dali::PanGesture *)jarg3;
57352   if (!arg3) {
57353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57354     return ;
57355   }
57356   {
57357     try {
57358       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57359     } catch (std::out_of_range& e) {
57360       {
57361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57362       };
57363     } catch (std::exception& e) {
57364       {
57365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57366       };
57367     } catch (Dali::DaliException e) {
57368       {
57369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57370       };
57371     } catch (...) {
57372       {
57373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57374       };
57375     }
57376   }
57377
57378 }
57379
57380
57381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57382   void * jresult ;
57383   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57384
57385   {
57386     try {
57387       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57388     } catch (std::out_of_range& e) {
57389       {
57390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57391       };
57392     } catch (std::exception& e) {
57393       {
57394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57395       };
57396     } catch (Dali::DaliException e) {
57397       {
57398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57399       };
57400     } catch (...) {
57401       {
57402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57403       };
57404     }
57405   }
57406
57407   jresult = (void *)result;
57408   return jresult;
57409 }
57410
57411
57412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57413   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57414
57415   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57416   {
57417     try {
57418       delete arg1;
57419     } catch (std::out_of_range& e) {
57420       {
57421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57422       };
57423     } catch (std::exception& e) {
57424       {
57425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57426       };
57427     } catch (Dali::DaliException e) {
57428       {
57429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57430       };
57431     } catch (...) {
57432       {
57433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57434       };
57435     }
57436   }
57437
57438 }
57439
57440
57441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57442   unsigned int jresult ;
57443   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57444   bool result;
57445
57446   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57447   {
57448     try {
57449       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);
57450     } catch (std::out_of_range& e) {
57451       {
57452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57453       };
57454     } catch (std::exception& e) {
57455       {
57456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57457       };
57458     } catch (Dali::DaliException e) {
57459       {
57460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57461       };
57462     } catch (...) {
57463       {
57464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57465       };
57466     }
57467   }
57468
57469   jresult = result;
57470   return jresult;
57471 }
57472
57473
57474 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57475   unsigned long jresult ;
57476   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57477   std::size_t result;
57478
57479   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57480   {
57481     try {
57482       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);
57483     } catch (std::out_of_range& e) {
57484       {
57485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57486       };
57487     } catch (std::exception& e) {
57488       {
57489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57490       };
57491     } catch (Dali::DaliException e) {
57492       {
57493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57494       };
57495     } catch (...) {
57496       {
57497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57498       };
57499     }
57500   }
57501
57502   jresult = (unsigned long)result;
57503   return jresult;
57504 }
57505
57506
57507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57508   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57509   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57510
57511   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57512   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57513   {
57514     try {
57515       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57516     } catch (std::out_of_range& e) {
57517       {
57518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57519       };
57520     } catch (std::exception& e) {
57521       {
57522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57523       };
57524     } catch (Dali::DaliException e) {
57525       {
57526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57527       };
57528     } catch (...) {
57529       {
57530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57531       };
57532     }
57533   }
57534
57535 }
57536
57537
57538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57539   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57540   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57541
57542   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57543   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57544   {
57545     try {
57546       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57547     } catch (std::out_of_range& e) {
57548       {
57549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57550       };
57551     } catch (std::exception& e) {
57552       {
57553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57554       };
57555     } catch (Dali::DaliException e) {
57556       {
57557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57558       };
57559     } catch (...) {
57560       {
57561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57562       };
57563     }
57564   }
57565
57566 }
57567
57568
57569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57570   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57571   Dali::Actor arg2 ;
57572   Dali::PinchGesture *arg3 = 0 ;
57573   Dali::Actor *argp2 ;
57574
57575   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57576   argp2 = (Dali::Actor *)jarg2;
57577   if (!argp2) {
57578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57579     return ;
57580   }
57581   arg2 = *argp2;
57582   arg3 = (Dali::PinchGesture *)jarg3;
57583   if (!arg3) {
57584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57585     return ;
57586   }
57587   {
57588     try {
57589       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57590     } catch (std::out_of_range& e) {
57591       {
57592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57593       };
57594     } catch (std::exception& e) {
57595       {
57596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57597       };
57598     } catch (Dali::DaliException e) {
57599       {
57600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57601       };
57602     } catch (...) {
57603       {
57604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57605       };
57606     }
57607   }
57608
57609 }
57610
57611
57612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57613   void * jresult ;
57614   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57615
57616   {
57617     try {
57618       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57619     } catch (std::out_of_range& e) {
57620       {
57621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57622       };
57623     } catch (std::exception& e) {
57624       {
57625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57626       };
57627     } catch (Dali::DaliException e) {
57628       {
57629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57630       };
57631     } catch (...) {
57632       {
57633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57634       };
57635     }
57636   }
57637
57638   jresult = (void *)result;
57639   return jresult;
57640 }
57641
57642
57643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57644   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57645
57646   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57647   {
57648     try {
57649       delete arg1;
57650     } catch (std::out_of_range& e) {
57651       {
57652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57653       };
57654     } catch (std::exception& e) {
57655       {
57656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57657       };
57658     } catch (Dali::DaliException e) {
57659       {
57660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57661       };
57662     } catch (...) {
57663       {
57664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57665       };
57666     }
57667   }
57668
57669 }
57670
57671
57672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57673   unsigned int jresult ;
57674   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57675   bool result;
57676
57677   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57678   {
57679     try {
57680       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);
57681     } catch (std::out_of_range& e) {
57682       {
57683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57684       };
57685     } catch (std::exception& e) {
57686       {
57687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57688       };
57689     } catch (Dali::DaliException e) {
57690       {
57691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57692       };
57693     } catch (...) {
57694       {
57695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57696       };
57697     }
57698   }
57699
57700   jresult = result;
57701   return jresult;
57702 }
57703
57704
57705 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57706   unsigned long jresult ;
57707   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57708   std::size_t result;
57709
57710   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57711   {
57712     try {
57713       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);
57714     } catch (std::out_of_range& e) {
57715       {
57716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57717       };
57718     } catch (std::exception& e) {
57719       {
57720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57721       };
57722     } catch (Dali::DaliException e) {
57723       {
57724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57725       };
57726     } catch (...) {
57727       {
57728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57729       };
57730     }
57731   }
57732
57733   jresult = (unsigned long)result;
57734   return jresult;
57735 }
57736
57737
57738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57739   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57740   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57741
57742   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57743   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57744   {
57745     try {
57746       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57747     } catch (std::out_of_range& e) {
57748       {
57749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57750       };
57751     } catch (std::exception& e) {
57752       {
57753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57754       };
57755     } catch (Dali::DaliException e) {
57756       {
57757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57758       };
57759     } catch (...) {
57760       {
57761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57762       };
57763     }
57764   }
57765
57766 }
57767
57768
57769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57770   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57771   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57772
57773   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57774   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57775   {
57776     try {
57777       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57778     } catch (std::out_of_range& e) {
57779       {
57780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57781       };
57782     } catch (std::exception& e) {
57783       {
57784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57785       };
57786     } catch (Dali::DaliException e) {
57787       {
57788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57789       };
57790     } catch (...) {
57791       {
57792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57793       };
57794     }
57795   }
57796
57797 }
57798
57799
57800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57801   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57802   Dali::Actor arg2 ;
57803   Dali::TapGesture *arg3 = 0 ;
57804   Dali::Actor *argp2 ;
57805
57806   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57807   argp2 = (Dali::Actor *)jarg2;
57808   if (!argp2) {
57809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57810     return ;
57811   }
57812   arg2 = *argp2;
57813   arg3 = (Dali::TapGesture *)jarg3;
57814   if (!arg3) {
57815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57816     return ;
57817   }
57818   {
57819     try {
57820       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57821     } catch (std::out_of_range& e) {
57822       {
57823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57824       };
57825     } catch (std::exception& e) {
57826       {
57827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57828       };
57829     } catch (Dali::DaliException e) {
57830       {
57831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57832       };
57833     } catch (...) {
57834       {
57835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57836       };
57837     }
57838   }
57839
57840 }
57841
57842
57843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57844   void * jresult ;
57845   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57846
57847   {
57848     try {
57849       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57850     } catch (std::out_of_range& e) {
57851       {
57852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57853       };
57854     } catch (std::exception& e) {
57855       {
57856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57857       };
57858     } catch (Dali::DaliException e) {
57859       {
57860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57861       };
57862     } catch (...) {
57863       {
57864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57865       };
57866     }
57867   }
57868
57869   jresult = (void *)result;
57870   return jresult;
57871 }
57872
57873
57874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57875   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57876
57877   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57878   {
57879     try {
57880       delete arg1;
57881     } catch (std::out_of_range& e) {
57882       {
57883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57884       };
57885     } catch (std::exception& e) {
57886       {
57887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57888       };
57889     } catch (Dali::DaliException e) {
57890       {
57891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57892       };
57893     } catch (...) {
57894       {
57895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57896       };
57897     }
57898   }
57899
57900 }
57901
57902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57903   unsigned int jresult ;
57904   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57905   bool result;
57906
57907   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57908   {
57909     try {
57910       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57911     } catch (std::out_of_range& e) {
57912       {
57913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57914       };
57915     } catch (std::exception& e) {
57916       {
57917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57918       };
57919     } catch (Dali::DaliException e) {
57920       {
57921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57922       };
57923     } catch (...) {
57924       {
57925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57926       };
57927     }
57928   }
57929
57930   jresult = result;
57931   return jresult;
57932 }
57933
57934
57935 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57936   unsigned long jresult ;
57937   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57938   std::size_t result;
57939
57940   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57941   {
57942     try {
57943       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57944     } catch (std::out_of_range& e) {
57945       {
57946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57947       };
57948     } catch (std::exception& e) {
57949       {
57950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57951       };
57952     } catch (Dali::DaliException e) {
57953       {
57954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57955       };
57956     } catch (...) {
57957       {
57958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57959       };
57960     }
57961   }
57962
57963   jresult = (unsigned long)result;
57964   return jresult;
57965 }
57966
57967
57968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57969   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57970   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57971
57972   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57973   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57974   {
57975     try {
57976       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57977     } catch (std::out_of_range& e) {
57978       {
57979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57980       };
57981     } catch (std::exception& e) {
57982       {
57983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57984       };
57985     } catch (Dali::DaliException e) {
57986       {
57987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57988       };
57989     } catch (...) {
57990       {
57991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57992       };
57993     }
57994   }
57995
57996 }
57997
57998
57999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
58000   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58001   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
58002
58003   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58004   arg2 = (void (*)(Dali::ResourceImage))jarg2;
58005   {
58006     try {
58007       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
58008     } catch (std::out_of_range& e) {
58009       {
58010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58011       };
58012     } catch (std::exception& e) {
58013       {
58014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58015       };
58016     } catch (Dali::DaliException e) {
58017       {
58018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58019       };
58020     } catch (...) {
58021       {
58022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58023       };
58024     }
58025   }
58026
58027 }
58028
58029
58030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
58031   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58032   Dali::ResourceImage arg2 ;
58033   Dali::ResourceImage *argp2 ;
58034
58035   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58036   argp2 = (Dali::ResourceImage *)jarg2;
58037   if (!argp2) {
58038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
58039     return ;
58040   }
58041   arg2 = *argp2;
58042   {
58043     try {
58044       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
58045     } catch (std::out_of_range& e) {
58046       {
58047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58048       };
58049     } catch (std::exception& e) {
58050       {
58051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58052       };
58053     } catch (Dali::DaliException e) {
58054       {
58055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58056       };
58057     } catch (...) {
58058       {
58059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58060       };
58061     }
58062   }
58063
58064 }
58065
58066
58067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
58068   void * jresult ;
58069   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
58070
58071   {
58072     try {
58073       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
58074     } catch (std::out_of_range& e) {
58075       {
58076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58077       };
58078     } catch (std::exception& e) {
58079       {
58080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58081       };
58082     } catch (Dali::DaliException e) {
58083       {
58084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58085       };
58086     } catch (...) {
58087       {
58088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58089       };
58090     }
58091   }
58092
58093   jresult = (void *)result;
58094   return jresult;
58095 }
58096
58097
58098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
58099   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58100
58101   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58102   {
58103     try {
58104       delete arg1;
58105     } catch (std::out_of_range& e) {
58106       {
58107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58108       };
58109     } catch (std::exception& e) {
58110       {
58111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58112       };
58113     } catch (Dali::DaliException e) {
58114       {
58115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58116       };
58117     } catch (...) {
58118       {
58119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58120       };
58121     }
58122   }
58123
58124 }
58125
58126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58127   unsigned int jresult ;
58128   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58129   bool result = false;
58130
58131   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58132   {
58133     try {
58134       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);
58135     } catch (std::out_of_range& e) {
58136       {
58137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58138       };
58139     } catch (std::exception& e) {
58140       {
58141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58142       };
58143     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58144   }
58145   jresult = result;
58146   return jresult;
58147 }
58148
58149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58150   unsigned long jresult ;
58151   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58152   std::size_t result = 0;
58153
58154   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58155   {
58156     try {
58157       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);
58158     } catch (std::out_of_range& e) {
58159       {
58160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58161       };
58162     } catch (std::exception& e) {
58163       {
58164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58165       };
58166     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58167   }
58168   jresult = (unsigned long)result;
58169   return jresult;
58170 }
58171
58172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58173   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58174   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58175
58176   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58177   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58178   {
58179     try {
58180       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58181     } catch (std::out_of_range& e) {
58182       {
58183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58184       };
58185     } catch (std::exception& e) {
58186       {
58187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58188       };
58189     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58190   }
58191 }
58192
58193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58194   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58195   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58196
58197   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58198   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58199   {
58200     try {
58201       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58202     } catch (std::out_of_range& e) {
58203       {
58204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58205       };
58206     } catch (std::exception& e) {
58207       {
58208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58209       };
58210     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58211   }
58212 }
58213
58214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58215   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58216   Dali::Actor arg2 ;
58217   //bool arg3 ;
58218   Dali::LayoutDirection::Type arg4 ;
58219   Dali::Actor *argp2 ;
58220
58221   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58222   argp2 = (Dali::Actor *)jarg2;
58223   if (!argp2) {
58224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58225     return ;
58226   }
58227   arg2 = *argp2;
58228   //arg3 = jarg3 ? true : false;
58229   arg4 = (Dali::LayoutDirection::Type)jarg4;
58230   {
58231     try {
58232       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58233     } catch (std::out_of_range& e) {
58234       {
58235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58236       };
58237     } catch (std::exception& e) {
58238       {
58239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58240       };
58241     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58242   }
58243 }
58244
58245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58246   void * jresult ;
58247   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58248
58249   {
58250     try {
58251       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58252     } catch (std::out_of_range& e) {
58253       {
58254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58255       };
58256     } catch (std::exception& e) {
58257       {
58258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58259       };
58260     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58261   }
58262   jresult = (void *)result;
58263   return jresult;
58264 }
58265
58266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58267   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58268
58269   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58270   {
58271     try {
58272       delete arg1;
58273     } catch (std::out_of_range& e) {
58274       {
58275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58276       };
58277     } catch (std::exception& e) {
58278       {
58279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58280       };
58281     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58282   }
58283 }
58284
58285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58286   unsigned int jresult ;
58287   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58288   bool result;
58289
58290   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58291   {
58292     try {
58293       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);
58294     } catch (std::out_of_range& e) {
58295       {
58296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58297       };
58298     } catch (std::exception& e) {
58299       {
58300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58301       };
58302     } catch (Dali::DaliException e) {
58303       {
58304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58305       };
58306     } catch (...) {
58307       {
58308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58309       };
58310     }
58311   }
58312
58313   jresult = result;
58314   return jresult;
58315 }
58316
58317
58318 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58319   unsigned long jresult ;
58320   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58321   std::size_t result;
58322
58323   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58324   {
58325     try {
58326       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);
58327     } catch (std::out_of_range& e) {
58328       {
58329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58330       };
58331     } catch (std::exception& e) {
58332       {
58333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58334       };
58335     } catch (Dali::DaliException e) {
58336       {
58337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58338       };
58339     } catch (...) {
58340       {
58341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58342       };
58343     }
58344   }
58345
58346   jresult = (unsigned long)result;
58347   return jresult;
58348 }
58349
58350
58351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58352   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58353   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58354
58355   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58356   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58357   {
58358     try {
58359       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58360     } catch (std::out_of_range& e) {
58361       {
58362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58363       };
58364     } catch (std::exception& e) {
58365       {
58366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58367       };
58368     } catch (Dali::DaliException e) {
58369       {
58370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58371       };
58372     } catch (...) {
58373       {
58374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58375       };
58376     }
58377   }
58378
58379 }
58380
58381
58382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58383   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58384   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58385
58386   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58387   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58388   {
58389     try {
58390       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58391     } catch (std::out_of_range& e) {
58392       {
58393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58394       };
58395     } catch (std::exception& e) {
58396       {
58397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58398       };
58399     } catch (Dali::DaliException e) {
58400       {
58401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58402       };
58403     } catch (...) {
58404       {
58405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58406       };
58407     }
58408   }
58409
58410 }
58411
58412
58413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58414   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58415   Dali::Actor arg2 ;
58416   bool arg3 ;
58417   Dali::DevelActor::VisibilityChange::Type arg4 ;
58418   Dali::Actor *argp2 ;
58419
58420   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58421   argp2 = (Dali::Actor *)jarg2;
58422   if (!argp2) {
58423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58424     return ;
58425   }
58426   arg2 = *argp2;
58427   arg3 = jarg3 ? true : false;
58428   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58429   {
58430     try {
58431       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58432     } catch (std::out_of_range& e) {
58433       {
58434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58435       };
58436     } catch (std::exception& e) {
58437       {
58438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58439       };
58440     } catch (Dali::DaliException e) {
58441       {
58442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58443       };
58444     } catch (...) {
58445       {
58446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58447       };
58448     }
58449   }
58450
58451 }
58452
58453
58454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58455   void * jresult ;
58456   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58457
58458   {
58459     try {
58460       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58461     } catch (std::out_of_range& e) {
58462       {
58463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58464       };
58465     } catch (std::exception& e) {
58466       {
58467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58468       };
58469     } catch (Dali::DaliException e) {
58470       {
58471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58472       };
58473     } catch (...) {
58474       {
58475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58476       };
58477     }
58478   }
58479
58480   jresult = (void *)result;
58481   return jresult;
58482 }
58483
58484
58485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58486   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58487
58488   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58489   {
58490     try {
58491       delete arg1;
58492     } catch (std::out_of_range& e) {
58493       {
58494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58495       };
58496     } catch (std::exception& e) {
58497       {
58498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58499       };
58500     } catch (Dali::DaliException e) {
58501       {
58502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58503       };
58504     } catch (...) {
58505       {
58506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58507       };
58508     }
58509   }
58510
58511 }
58512
58513
58514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58515   void * jresult ;
58516   Dali::Timer *result = 0 ;
58517
58518   {
58519     try {
58520       result = (Dali::Timer *)new Dali::Timer();
58521     } catch (std::out_of_range& e) {
58522       {
58523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58524       };
58525     } catch (std::exception& e) {
58526       {
58527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58528       };
58529     } catch (Dali::DaliException e) {
58530       {
58531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58532       };
58533     } catch (...) {
58534       {
58535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58536       };
58537     }
58538   }
58539
58540   jresult = (void *)result;
58541   return jresult;
58542 }
58543
58544
58545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58546   void * jresult ;
58547   unsigned int arg1 ;
58548   Dali::Timer result;
58549
58550   arg1 = (unsigned int)jarg1;
58551   {
58552     try {
58553       result = Dali::Timer::New(arg1);
58554     } catch (std::out_of_range& e) {
58555       {
58556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58557       };
58558     } catch (std::exception& e) {
58559       {
58560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58561       };
58562     } catch (Dali::DaliException e) {
58563       {
58564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58565       };
58566     } catch (...) {
58567       {
58568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58569       };
58570     }
58571   }
58572
58573   jresult = new Dali::Timer((const Dali::Timer &)result);
58574   return jresult;
58575 }
58576
58577
58578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58579   void * jresult ;
58580   Dali::Timer *arg1 = 0 ;
58581   Dali::Timer *result = 0 ;
58582
58583   arg1 = (Dali::Timer *)jarg1;
58584   if (!arg1) {
58585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58586     return 0;
58587   }
58588   {
58589     try {
58590       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58591     } catch (std::out_of_range& e) {
58592       {
58593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58594       };
58595     } catch (std::exception& e) {
58596       {
58597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58598       };
58599     } catch (Dali::DaliException e) {
58600       {
58601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58602       };
58603     } catch (...) {
58604       {
58605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58606       };
58607     }
58608   }
58609
58610   jresult = (void *)result;
58611   return jresult;
58612 }
58613
58614
58615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58616   void * jresult ;
58617   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58618   Dali::Timer *arg2 = 0 ;
58619   Dali::Timer *result = 0 ;
58620
58621   arg1 = (Dali::Timer *)jarg1;
58622   arg2 = (Dali::Timer *)jarg2;
58623   if (!arg2) {
58624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58625     return 0;
58626   }
58627   {
58628     try {
58629       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58630     } catch (std::out_of_range& e) {
58631       {
58632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58633       };
58634     } catch (std::exception& e) {
58635       {
58636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58637       };
58638     } catch (Dali::DaliException e) {
58639       {
58640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58641       };
58642     } catch (...) {
58643       {
58644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58645       };
58646     }
58647   }
58648
58649   jresult = (void *)result;
58650   return jresult;
58651 }
58652
58653
58654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58655   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58656
58657   arg1 = (Dali::Timer *)jarg1;
58658   {
58659     try {
58660       delete arg1;
58661     } catch (std::out_of_range& e) {
58662       {
58663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58664       };
58665     } catch (std::exception& e) {
58666       {
58667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58668       };
58669     } catch (Dali::DaliException e) {
58670       {
58671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58672       };
58673     } catch (...) {
58674       {
58675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58676       };
58677     }
58678   }
58679
58680 }
58681
58682
58683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58684   void * jresult ;
58685   Dali::BaseHandle arg1 ;
58686   Dali::BaseHandle *argp1 ;
58687   Dali::Timer result;
58688
58689   argp1 = (Dali::BaseHandle *)jarg1;
58690   if (!argp1) {
58691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58692     return 0;
58693   }
58694   arg1 = *argp1;
58695   {
58696     try {
58697       result = Dali::Timer::DownCast(arg1);
58698     } catch (std::out_of_range& e) {
58699       {
58700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58701       };
58702     } catch (std::exception& e) {
58703       {
58704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58705       };
58706     } catch (Dali::DaliException e) {
58707       {
58708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58709       };
58710     } catch (...) {
58711       {
58712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58713       };
58714     }
58715   }
58716
58717   jresult = new Dali::Timer((const Dali::Timer &)result);
58718   return jresult;
58719 }
58720
58721
58722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58723   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58724
58725   arg1 = (Dali::Timer *)jarg1;
58726   {
58727     try {
58728       (arg1)->Start();
58729     } catch (std::out_of_range& e) {
58730       {
58731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58732       };
58733     } catch (std::exception& e) {
58734       {
58735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58736       };
58737     } catch (Dali::DaliException e) {
58738       {
58739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58740       };
58741     } catch (...) {
58742       {
58743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58744       };
58745     }
58746   }
58747
58748 }
58749
58750
58751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58752   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58753
58754   arg1 = (Dali::Timer *)jarg1;
58755   {
58756     try {
58757       (arg1)->Stop();
58758     } catch (std::out_of_range& e) {
58759       {
58760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58761       };
58762     } catch (std::exception& e) {
58763       {
58764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58765       };
58766     } catch (Dali::DaliException e) {
58767       {
58768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58769       };
58770     } catch (...) {
58771       {
58772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58773       };
58774     }
58775   }
58776
58777 }
58778
58779
58780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58781   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58782   unsigned int arg2 ;
58783
58784   arg1 = (Dali::Timer *)jarg1;
58785   arg2 = (unsigned int)jarg2;
58786   {
58787     try {
58788       (arg1)->SetInterval(arg2);
58789     } catch (std::out_of_range& e) {
58790       {
58791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58792       };
58793     } catch (std::exception& e) {
58794       {
58795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58796       };
58797     } catch (Dali::DaliException e) {
58798       {
58799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58800       };
58801     } catch (...) {
58802       {
58803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58804       };
58805     }
58806   }
58807
58808 }
58809
58810
58811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58812   unsigned int jresult ;
58813   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58814   unsigned int result;
58815
58816   arg1 = (Dali::Timer *)jarg1;
58817   {
58818     try {
58819       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58820     } catch (std::out_of_range& e) {
58821       {
58822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58823       };
58824     } catch (std::exception& e) {
58825       {
58826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58827       };
58828     } catch (Dali::DaliException e) {
58829       {
58830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58831       };
58832     } catch (...) {
58833       {
58834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58835       };
58836     }
58837   }
58838
58839   jresult = result;
58840   return jresult;
58841 }
58842
58843
58844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58845   unsigned int jresult ;
58846   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58847   bool result;
58848
58849   arg1 = (Dali::Timer *)jarg1;
58850   {
58851     try {
58852       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58853     } catch (std::out_of_range& e) {
58854       {
58855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58856       };
58857     } catch (std::exception& e) {
58858       {
58859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58860       };
58861     } catch (Dali::DaliException e) {
58862       {
58863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58864       };
58865     } catch (...) {
58866       {
58867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58868       };
58869     }
58870   }
58871
58872   jresult = result;
58873   return jresult;
58874 }
58875
58876
58877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58878   void * jresult ;
58879   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58880   Dali::Timer::TimerSignalType *result = 0 ;
58881
58882   arg1 = (Dali::Timer *)jarg1;
58883   {
58884     try {
58885       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58886     } catch (std::out_of_range& e) {
58887       {
58888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58889       };
58890     } catch (std::exception& e) {
58891       {
58892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58893       };
58894     } catch (Dali::DaliException e) {
58895       {
58896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58897       };
58898     } catch (...) {
58899       {
58900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58901       };
58902     }
58903   }
58904
58905   jresult = (void *)result;
58906   return jresult;
58907 }
58908
58909
58910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58911   unsigned int jresult ;
58912   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58913   bool result;
58914
58915   arg1 = (Dali::Signal< bool () > *)jarg1;
58916   {
58917     try {
58918       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58919     } catch (std::out_of_range& e) {
58920       {
58921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58922       };
58923     } catch (std::exception& e) {
58924       {
58925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58926       };
58927     } catch (Dali::DaliException e) {
58928       {
58929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58930       };
58931     } catch (...) {
58932       {
58933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58934       };
58935     }
58936   }
58937
58938   jresult = result;
58939   return jresult;
58940 }
58941
58942
58943 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58944   unsigned long jresult ;
58945   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58946   std::size_t result;
58947
58948   arg1 = (Dali::Signal< bool () > *)jarg1;
58949   {
58950     try {
58951       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58952     } catch (std::out_of_range& e) {
58953       {
58954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58955       };
58956     } catch (std::exception& e) {
58957       {
58958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58959       };
58960     } catch (Dali::DaliException e) {
58961       {
58962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58963       };
58964     } catch (...) {
58965       {
58966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58967       };
58968     }
58969   }
58970
58971   jresult = (unsigned long)result;
58972   return jresult;
58973 }
58974
58975
58976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58977   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58978   bool (*arg2)() = (bool (*)()) 0 ;
58979
58980   arg1 = (Dali::Signal< bool () > *)jarg1;
58981   arg2 = (bool (*)())jarg2;
58982   {
58983     try {
58984       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58985     } catch (std::out_of_range& e) {
58986       {
58987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58988       };
58989     } catch (std::exception& e) {
58990       {
58991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58992       };
58993     } catch (Dali::DaliException e) {
58994       {
58995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58996       };
58997     } catch (...) {
58998       {
58999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59000       };
59001     }
59002   }
59003
59004 }
59005
59006
59007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59008   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59009   bool (*arg2)() = (bool (*)()) 0 ;
59010
59011   arg1 = (Dali::Signal< bool () > *)jarg1;
59012   arg2 = (bool (*)())jarg2;
59013   {
59014     try {
59015       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59016     } catch (std::out_of_range& e) {
59017       {
59018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59019       };
59020     } catch (std::exception& e) {
59021       {
59022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59023       };
59024     } catch (Dali::DaliException e) {
59025       {
59026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59027       };
59028     } catch (...) {
59029       {
59030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59031       };
59032     }
59033   }
59034
59035 }
59036
59037
59038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59039   unsigned int jresult ;
59040   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59041   bool result;
59042
59043   arg1 = (Dali::Signal< bool () > *)jarg1;
59044   {
59045     try {
59046       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59047     } catch (std::out_of_range& e) {
59048       {
59049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59050       };
59051     } catch (std::exception& e) {
59052       {
59053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59054       };
59055     } catch (Dali::DaliException e) {
59056       {
59057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59058       };
59059     } catch (...) {
59060       {
59061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59062       };
59063     }
59064   }
59065
59066   jresult = result;
59067   return jresult;
59068 }
59069
59070
59071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59072   void * jresult ;
59073   Dali::Signal< bool () > *result = 0 ;
59074
59075   {
59076     try {
59077       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59078     } catch (std::out_of_range& e) {
59079       {
59080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59081       };
59082     } catch (std::exception& e) {
59083       {
59084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59085       };
59086     } catch (Dali::DaliException e) {
59087       {
59088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59089       };
59090     } catch (...) {
59091       {
59092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59093       };
59094     }
59095   }
59096
59097   jresult = (void *)result;
59098   return jresult;
59099 }
59100
59101
59102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59103   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59104
59105   arg1 = (Dali::Signal< bool () > *)jarg1;
59106   {
59107     try {
59108       delete arg1;
59109     } catch (std::out_of_range& e) {
59110       {
59111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59112       };
59113     } catch (std::exception& e) {
59114       {
59115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59116       };
59117     } catch (Dali::DaliException e) {
59118       {
59119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59120       };
59121     } catch (...) {
59122       {
59123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59124       };
59125     }
59126   }
59127
59128 }
59129
59130
59131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59132   int jresult ;
59133   int result;
59134
59135   {
59136     try {
59137       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59138     } catch (std::out_of_range& e) {
59139       {
59140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59141       };
59142     } catch (std::exception& e) {
59143       {
59144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59145       };
59146     } catch (Dali::DaliException e) {
59147       {
59148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59149       };
59150     } catch (...) {
59151       {
59152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59153       };
59154     }
59155   }
59156
59157   jresult = (int)result;
59158   return jresult;
59159 }
59160
59161
59162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59163   int jresult ;
59164   int result;
59165
59166   {
59167     try {
59168       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59169     } catch (std::out_of_range& e) {
59170       {
59171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59172       };
59173     } catch (std::exception& e) {
59174       {
59175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59176       };
59177     } catch (Dali::DaliException e) {
59178       {
59179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59180       };
59181     } catch (...) {
59182       {
59183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59184       };
59185     }
59186   }
59187
59188   jresult = (int)result;
59189   return jresult;
59190 }
59191
59192
59193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59194   int jresult ;
59195   int result;
59196
59197   {
59198     try {
59199       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59200     } catch (std::out_of_range& e) {
59201       {
59202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59203       };
59204     } catch (std::exception& e) {
59205       {
59206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59207       };
59208     } catch (Dali::DaliException e) {
59209       {
59210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59211       };
59212     } catch (...) {
59213       {
59214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59215       };
59216     }
59217   }
59218
59219   jresult = (int)result;
59220   return jresult;
59221 }
59222
59223
59224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59225   int jresult ;
59226   int result;
59227
59228   {
59229     try {
59230       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59231     } catch (std::out_of_range& e) {
59232       {
59233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59234       };
59235     } catch (std::exception& e) {
59236       {
59237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59238       };
59239     } catch (Dali::DaliException e) {
59240       {
59241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59242       };
59243     } catch (...) {
59244       {
59245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59246       };
59247     }
59248   }
59249
59250   jresult = (int)result;
59251   return jresult;
59252 }
59253
59254
59255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59256   int jresult ;
59257   int result;
59258
59259   {
59260     try {
59261       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59262     } catch (std::out_of_range& e) {
59263       {
59264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59265       };
59266     } catch (std::exception& e) {
59267       {
59268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59269       };
59270     } catch (Dali::DaliException e) {
59271       {
59272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59273       };
59274     } catch (...) {
59275       {
59276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59277       };
59278     }
59279   }
59280
59281   jresult = (int)result;
59282   return jresult;
59283 }
59284
59285
59286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59287   int jresult ;
59288   int result;
59289
59290   {
59291     try {
59292       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59293     } catch (std::out_of_range& e) {
59294       {
59295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59296       };
59297     } catch (std::exception& e) {
59298       {
59299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59300       };
59301     } catch (Dali::DaliException e) {
59302       {
59303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59304       };
59305     } catch (...) {
59306       {
59307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59308       };
59309     }
59310   }
59311
59312   jresult = (int)result;
59313   return jresult;
59314 }
59315
59316
59317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59318   int jresult ;
59319   int result;
59320
59321   {
59322     try {
59323       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59324     } catch (std::out_of_range& e) {
59325       {
59326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59327       };
59328     } catch (std::exception& e) {
59329       {
59330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59331       };
59332     } catch (Dali::DaliException e) {
59333       {
59334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59335       };
59336     } catch (...) {
59337       {
59338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59339       };
59340     }
59341   }
59342
59343   jresult = (int)result;
59344   return jresult;
59345 }
59346
59347
59348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59349   int jresult ;
59350   int result;
59351
59352   {
59353     try {
59354       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59355     } catch (std::out_of_range& e) {
59356       {
59357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59358       };
59359     } catch (std::exception& e) {
59360       {
59361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59362       };
59363     } catch (Dali::DaliException e) {
59364       {
59365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59366       };
59367     } catch (...) {
59368       {
59369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59370       };
59371     }
59372   }
59373
59374   jresult = (int)result;
59375   return jresult;
59376 }
59377
59378
59379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59380   int jresult ;
59381   int result;
59382
59383   {
59384     try {
59385       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59386     } catch (std::out_of_range& e) {
59387       {
59388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59389       };
59390     } catch (std::exception& e) {
59391       {
59392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59393       };
59394     } catch (Dali::DaliException e) {
59395       {
59396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59397       };
59398     } catch (...) {
59399       {
59400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59401       };
59402     }
59403   }
59404
59405   jresult = (int)result;
59406   return jresult;
59407 }
59408
59409
59410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59411   int jresult ;
59412   int result;
59413
59414   {
59415     try {
59416       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59417     } catch (std::out_of_range& e) {
59418       {
59419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59420       };
59421     } catch (std::exception& e) {
59422       {
59423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59424       };
59425     } catch (Dali::DaliException e) {
59426       {
59427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59428       };
59429     } catch (...) {
59430       {
59431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59432       };
59433     }
59434   }
59435
59436   jresult = (int)result;
59437   return jresult;
59438 }
59439
59440
59441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59442   int jresult ;
59443   int result;
59444
59445   {
59446     try {
59447       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59448     } catch (std::out_of_range& e) {
59449       {
59450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59451       };
59452     } catch (std::exception& e) {
59453       {
59454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59455       };
59456     } catch (Dali::DaliException e) {
59457       {
59458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59459       };
59460     } catch (...) {
59461       {
59462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59463       };
59464     }
59465   }
59466
59467   jresult = (int)result;
59468   return jresult;
59469 }
59470
59471
59472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59473   int jresult ;
59474   int result;
59475
59476   {
59477     try {
59478       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59479     } catch (std::out_of_range& e) {
59480       {
59481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59482       };
59483     } catch (std::exception& e) {
59484       {
59485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59486       };
59487     } catch (Dali::DaliException e) {
59488       {
59489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59490       };
59491     } catch (...) {
59492       {
59493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59494       };
59495     }
59496   }
59497
59498   jresult = (int)result;
59499   return jresult;
59500 }
59501
59502
59503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59504   int jresult ;
59505   int result;
59506
59507   {
59508     try {
59509       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59510     } catch (std::out_of_range& e) {
59511       {
59512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59513       };
59514     } catch (std::exception& e) {
59515       {
59516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59517       };
59518     } catch (Dali::DaliException e) {
59519       {
59520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59521       };
59522     } catch (...) {
59523       {
59524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59525       };
59526     }
59527   }
59528
59529   jresult = (int)result;
59530   return jresult;
59531 }
59532
59533
59534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59535   int jresult ;
59536   int result;
59537
59538   {
59539     try {
59540       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59541     } catch (std::out_of_range& e) {
59542       {
59543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59544       };
59545     } catch (std::exception& e) {
59546       {
59547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59548       };
59549     } catch (Dali::DaliException e) {
59550       {
59551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59552       };
59553     } catch (...) {
59554       {
59555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59556       };
59557     }
59558   }
59559
59560   jresult = (int)result;
59561   return jresult;
59562 }
59563
59564
59565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59566   int jresult ;
59567   int result;
59568
59569   {
59570     try {
59571       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59572     } catch (std::out_of_range& e) {
59573       {
59574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59575       };
59576     } catch (std::exception& e) {
59577       {
59578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59579       };
59580     } catch (Dali::DaliException e) {
59581       {
59582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59583       };
59584     } catch (...) {
59585       {
59586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59587       };
59588     }
59589   }
59590
59591   jresult = (int)result;
59592   return jresult;
59593 }
59594
59595
59596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59597   int jresult ;
59598   int result;
59599
59600   {
59601     try {
59602       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59603     } catch (std::out_of_range& e) {
59604       {
59605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59606       };
59607     } catch (std::exception& e) {
59608       {
59609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59610       };
59611     } catch (Dali::DaliException e) {
59612       {
59613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59614       };
59615     } catch (...) {
59616       {
59617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59618       };
59619     }
59620   }
59621
59622   jresult = (int)result;
59623   return jresult;
59624 }
59625
59626
59627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59628   int jresult ;
59629   int result;
59630
59631   {
59632     try {
59633       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59634     } catch (std::out_of_range& e) {
59635       {
59636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59637       };
59638     } catch (std::exception& e) {
59639       {
59640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59641       };
59642     } catch (Dali::DaliException e) {
59643       {
59644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59645       };
59646     } catch (...) {
59647       {
59648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59649       };
59650     }
59651   }
59652
59653   jresult = (int)result;
59654   return jresult;
59655 }
59656
59657
59658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59659   int jresult ;
59660   int result;
59661
59662   {
59663     try {
59664       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59665     } catch (std::out_of_range& e) {
59666       {
59667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59668       };
59669     } catch (std::exception& e) {
59670       {
59671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59672       };
59673     } catch (Dali::DaliException e) {
59674       {
59675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59676       };
59677     } catch (...) {
59678       {
59679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59680       };
59681     }
59682   }
59683
59684   jresult = (int)result;
59685   return jresult;
59686 }
59687
59688
59689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59690   int jresult ;
59691   int result;
59692
59693   {
59694     try {
59695       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59696     } catch (std::out_of_range& e) {
59697       {
59698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59699       };
59700     } catch (std::exception& e) {
59701       {
59702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59703       };
59704     } catch (Dali::DaliException e) {
59705       {
59706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59707       };
59708     } catch (...) {
59709       {
59710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59711       };
59712     }
59713   }
59714
59715   jresult = (int)result;
59716   return jresult;
59717 }
59718
59719
59720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59721   int jresult ;
59722   int result;
59723
59724   {
59725     try {
59726       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59727     } catch (std::out_of_range& e) {
59728       {
59729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59730       };
59731     } catch (std::exception& e) {
59732       {
59733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59734       };
59735     } catch (Dali::DaliException e) {
59736       {
59737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59738       };
59739     } catch (...) {
59740       {
59741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59742       };
59743     }
59744   }
59745
59746   jresult = (int)result;
59747   return jresult;
59748 }
59749
59750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59751   int jresult ;
59752   int result;
59753
59754   {
59755     try {
59756       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59757     } catch (std::out_of_range& e) {
59758       {
59759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59760       };
59761     } catch (std::exception& e) {
59762       {
59763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59764       };
59765     } catch (Dali::DaliException e) {
59766       {
59767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59768       };
59769     } catch (...) {
59770       {
59771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59772       };
59773     }
59774   }
59775
59776   jresult = (int)result;
59777   return jresult;
59778 }
59779
59780
59781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59782   int jresult ;
59783   int result;
59784   {
59785     try
59786     {
59787       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59788     } catch (std::out_of_range& e) {
59789       {
59790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59791       };
59792     } catch (std::exception& e) {
59793       {
59794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59795       };
59796     } catch (Dali::DaliException e) {
59797       {
59798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59799       };
59800     } catch (...) {
59801       {
59802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59803       };
59804     }
59805   }
59806
59807   jresult = (int)result;
59808   return jresult;
59809 }
59810
59811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59812   int jresult ;
59813   int result;
59814   {
59815     try
59816     {
59817       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59818     } catch (std::out_of_range& e) {
59819       {
59820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59821       };
59822     } catch (std::exception& e) {
59823       {
59824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59825       };
59826     } catch (Dali::DaliException e) {
59827       {
59828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59829       };
59830     } catch (...) {
59831       {
59832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59833       };
59834     }
59835   }
59836
59837   jresult = (int)result;
59838   return jresult;
59839 }
59840
59841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59842   int jresult ;
59843   int result;
59844   {
59845     try
59846     {
59847       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59848     } catch (std::out_of_range& e) {
59849       {
59850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59851       };
59852     } catch (std::exception& e) {
59853       {
59854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59855       };
59856     } catch (Dali::DaliException e) {
59857       {
59858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59859       };
59860     } catch (...) {
59861       {
59862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59863       };
59864     }
59865   }
59866
59867   jresult = (int)result;
59868   return jresult;
59869 }
59870
59871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59872   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59873 }
59874
59875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59876   int jresult ;
59877   int result;
59878   {
59879     try
59880     {
59881       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59882     } catch (std::out_of_range& e) {
59883       {
59884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59885       };
59886     } catch (std::exception& e) {
59887       {
59888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59889       };
59890     } catch (Dali::DaliException e) {
59891       {
59892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59893       };
59894     } catch (...) {
59895       {
59896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59897       };
59898     }
59899   }
59900
59901   jresult = (int)result;
59902   return jresult;
59903 }
59904
59905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59906   int jresult ;
59907   int result;
59908   {
59909     try
59910     {
59911       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59912     } catch (std::out_of_range& e) {
59913       {
59914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59915       };
59916     } catch (std::exception& e) {
59917       {
59918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59919       };
59920     } catch (Dali::DaliException e) {
59921       {
59922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59923       };
59924     } catch (...) {
59925       {
59926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59927       };
59928     }
59929   }
59930
59931   jresult = (int)result;
59932   return jresult;
59933 }
59934
59935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59936   int jresult ;
59937   int result;
59938
59939   {
59940     try {
59941       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59942     } catch (std::out_of_range& e) {
59943       {
59944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59945       };
59946     } catch (std::exception& e) {
59947       {
59948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59949       };
59950     } catch (Dali::DaliException e) {
59951       {
59952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59953       };
59954     } catch (...) {
59955       {
59956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59957       };
59958     }
59959   }
59960
59961   jresult = (int)result;
59962   return jresult;
59963 }
59964
59965
59966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59967   int jresult ;
59968   int result;
59969
59970   {
59971     try {
59972       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59973     } catch (std::out_of_range& e) {
59974       {
59975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59976       };
59977     } catch (std::exception& e) {
59978       {
59979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59980       };
59981     } catch (Dali::DaliException e) {
59982       {
59983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59984       };
59985     } catch (...) {
59986       {
59987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59988       };
59989     }
59990   }
59991
59992   jresult = (int)result;
59993   return jresult;
59994 }
59995
59996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59997   int jresult ;
59998   int result;
59999   {
60000     try
60001     {
60002       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60003     } catch (std::out_of_range& e) {
60004       {
60005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60006       };
60007     } catch (std::exception& e) {
60008       {
60009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60010       };
60011     } catch (...) {
60012       {
60013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60014       };
60015     }
60016   }
60017   jresult = (int)result;
60018   return jresult;
60019 }
60020
60021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60022   int jresult ;
60023   int result;
60024   {
60025     try
60026     {
60027       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60028     } catch (std::out_of_range& e) {
60029       {
60030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60031       };
60032     } catch (std::exception& e) {
60033       {
60034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60035       };
60036     } catch (...) {
60037       {
60038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60039       };
60040     }
60041   }
60042   jresult = (int)result;
60043   return jresult;
60044 }
60045
60046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60047   int jresult ;
60048   int result;
60049   {
60050     try
60051     {
60052       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60053     } catch (std::out_of_range& e) {
60054       {
60055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60056       };
60057     } catch (std::exception& e) {
60058       {
60059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60060       };
60061     } catch (...) {
60062       {
60063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60064       };
60065     }
60066   }
60067   jresult = (int)result;
60068   return jresult;
60069 }
60070
60071
60072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60073   int jresult ;
60074   int result;
60075   {
60076     try
60077     {
60078       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60079     } catch (std::out_of_range& e) {
60080       {
60081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60082       };
60083     } catch (std::exception& e) {
60084       {
60085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60086       };
60087     } catch (...) {
60088       {
60089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60090       };
60091     }
60092   }
60093   jresult = (int)result;
60094   return jresult;
60095 }
60096
60097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60098   int jresult ;
60099   int result;
60100   {
60101     try
60102     {
60103       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60104     } catch (std::out_of_range& e) {
60105       {
60106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60107       };
60108     } catch (std::exception& e) {
60109       {
60110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60111       };
60112     } catch (...) {
60113       {
60114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60115       };
60116     }
60117   }
60118   jresult = (int)result;
60119   return jresult;
60120 }
60121
60122
60123
60124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60125   int jresult ;
60126   int result;
60127
60128   {
60129     try {
60130       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60131     } catch (std::out_of_range& e) {
60132       {
60133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60134       };
60135     } catch (std::exception& e) {
60136       {
60137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60138       };
60139     } catch (Dali::DaliException e) {
60140       {
60141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60142       };
60143     } catch (...) {
60144       {
60145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60146       };
60147     }
60148   }
60149
60150   jresult = (int)result;
60151   return jresult;
60152 }
60153
60154
60155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60156   int jresult ;
60157   int result;
60158
60159   {
60160     try {
60161       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60162     } catch (std::out_of_range& e) {
60163       {
60164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60165       };
60166     } catch (std::exception& e) {
60167       {
60168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60169       };
60170     } catch (Dali::DaliException e) {
60171       {
60172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60173       };
60174     } catch (...) {
60175       {
60176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60177       };
60178     }
60179   }
60180
60181   jresult = (int)result;
60182   return jresult;
60183 }
60184
60185
60186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60187   int jresult ;
60188   int result;
60189
60190   {
60191     try {
60192       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60193     } catch (std::out_of_range& e) {
60194       {
60195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60196       };
60197     } catch (std::exception& e) {
60198       {
60199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60200       };
60201     } catch (Dali::DaliException e) {
60202       {
60203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60204       };
60205     } catch (...) {
60206       {
60207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60208       };
60209     }
60210   }
60211
60212   jresult = (int)result;
60213   return jresult;
60214 }
60215
60216
60217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60218   int jresult ;
60219   int result;
60220
60221   {
60222     try {
60223       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60224     } catch (std::out_of_range& e) {
60225       {
60226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60227       };
60228     } catch (std::exception& e) {
60229       {
60230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60231       };
60232     } catch (Dali::DaliException e) {
60233       {
60234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60235       };
60236     } catch (...) {
60237       {
60238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60239       };
60240     }
60241   }
60242
60243   jresult = (int)result;
60244   return jresult;
60245 }
60246
60247
60248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60249   int jresult ;
60250   int result;
60251
60252   {
60253     try {
60254       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60255     } catch (std::out_of_range& e) {
60256       {
60257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60258       };
60259     } catch (std::exception& e) {
60260       {
60261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60262       };
60263     } catch (Dali::DaliException e) {
60264       {
60265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60266       };
60267     } catch (...) {
60268       {
60269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60270       };
60271     }
60272   }
60273
60274   jresult = (int)result;
60275   return jresult;
60276 }
60277
60278
60279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60280   int jresult ;
60281   int result;
60282
60283   {
60284     try {
60285       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60286     } catch (std::out_of_range& e) {
60287       {
60288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60289       };
60290     } catch (std::exception& e) {
60291       {
60292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60293       };
60294     } catch (Dali::DaliException e) {
60295       {
60296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60297       };
60298     } catch (...) {
60299       {
60300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60301       };
60302     }
60303   }
60304
60305   jresult = (int)result;
60306   return jresult;
60307 }
60308
60309
60310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60311   int jresult ;
60312   int result;
60313
60314   {
60315     try {
60316       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60317     } catch (std::out_of_range& e) {
60318       {
60319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60320       };
60321     } catch (std::exception& e) {
60322       {
60323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60324       };
60325     } catch (Dali::DaliException e) {
60326       {
60327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60328       };
60329     } catch (...) {
60330       {
60331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60332       };
60333     }
60334   }
60335
60336   jresult = (int)result;
60337   return jresult;
60338 }
60339
60340 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60341   int jresult ;
60342   int result;
60343
60344   {
60345     try {
60346       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60347     } catch (std::out_of_range& e) {
60348       {
60349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60350       };
60351     } catch (std::exception& e) {
60352       {
60353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60354       };
60355     } catch (...) {
60356       {
60357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60358       };
60359     }
60360   }
60361   jresult = (int)result;
60362   return jresult;
60363 }
60364
60365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60366   int jresult ;
60367   int result;
60368
60369   {
60370     try {
60371       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60372     } catch (std::out_of_range& e) {
60373       {
60374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60375       };
60376     } catch (std::exception& e) {
60377       {
60378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60379       };
60380     } catch (Dali::DaliException e) {
60381       {
60382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60383       };
60384     } catch (...) {
60385       {
60386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60387       };
60388     }
60389   }
60390
60391   jresult = (int)result;
60392   return jresult;
60393 }
60394
60395
60396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60397   int jresult ;
60398   int result;
60399
60400   {
60401     try {
60402       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60403     } catch (std::out_of_range& e) {
60404       {
60405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60406       };
60407     } catch (std::exception& e) {
60408       {
60409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60410       };
60411     } catch (Dali::DaliException e) {
60412       {
60413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60414       };
60415     } catch (...) {
60416       {
60417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60418       };
60419     }
60420   }
60421
60422   jresult = (int)result;
60423   return jresult;
60424 }
60425
60426
60427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60428   int jresult ;
60429   int result;
60430
60431   {
60432     try {
60433       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60434     } catch (std::out_of_range& e) {
60435       {
60436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60437       };
60438     } catch (std::exception& e) {
60439       {
60440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60441       };
60442     } catch (Dali::DaliException e) {
60443       {
60444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60445       };
60446     } catch (...) {
60447       {
60448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60449       };
60450     }
60451   }
60452
60453   jresult = (int)result;
60454   return jresult;
60455 }
60456
60457
60458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60459   int jresult ;
60460   int result;
60461
60462   {
60463     try {
60464       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60465     } catch (std::out_of_range& e) {
60466       {
60467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60468       };
60469     } catch (std::exception& e) {
60470       {
60471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60472       };
60473     } catch (Dali::DaliException e) {
60474       {
60475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60476       };
60477     } catch (...) {
60478       {
60479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60480       };
60481     }
60482   }
60483
60484   jresult = (int)result;
60485   return jresult;
60486 }
60487
60488
60489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60490   int jresult ;
60491   int result;
60492
60493   {
60494     try {
60495       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60496     } catch (std::out_of_range& e) {
60497       {
60498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60499       };
60500     } catch (std::exception& e) {
60501       {
60502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60503       };
60504     } catch (Dali::DaliException e) {
60505       {
60506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60507       };
60508     } catch (...) {
60509       {
60510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60511       };
60512     }
60513   }
60514
60515   jresult = (int)result;
60516   return jresult;
60517 }
60518
60519
60520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60521   int jresult ;
60522   int result;
60523
60524   {
60525     try {
60526       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60527     } catch (std::out_of_range& e) {
60528       {
60529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60530       };
60531     } catch (std::exception& e) {
60532       {
60533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60534       };
60535     } catch (Dali::DaliException e) {
60536       {
60537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60538       };
60539     } catch (...) {
60540       {
60541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60542       };
60543     }
60544   }
60545
60546   jresult = (int)result;
60547   return jresult;
60548 }
60549
60550
60551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60552   int jresult ;
60553   int result;
60554
60555   {
60556     try {
60557       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60558     } catch (std::out_of_range& e) {
60559       {
60560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60561       };
60562     } catch (std::exception& e) {
60563       {
60564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60565       };
60566     } catch (Dali::DaliException e) {
60567       {
60568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60569       };
60570     } catch (...) {
60571       {
60572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60573       };
60574     }
60575   }
60576
60577   jresult = (int)result;
60578   return jresult;
60579 }
60580
60581
60582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60583   int jresult ;
60584   int result;
60585
60586   {
60587     try {
60588       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60589     } catch (std::out_of_range& e) {
60590       {
60591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60592       };
60593     } catch (std::exception& e) {
60594       {
60595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60596       };
60597     } catch (Dali::DaliException e) {
60598       {
60599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60600       };
60601     } catch (...) {
60602       {
60603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60604       };
60605     }
60606   }
60607
60608   jresult = (int)result;
60609   return jresult;
60610 }
60611
60612
60613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60614   int jresult ;
60615   int result;
60616
60617   {
60618     try {
60619       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60620     } catch (std::out_of_range& e) {
60621       {
60622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60623       };
60624     } catch (std::exception& e) {
60625       {
60626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60627       };
60628     } catch (Dali::DaliException e) {
60629       {
60630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60631       };
60632     } catch (...) {
60633       {
60634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60635       };
60636     }
60637   }
60638
60639   jresult = (int)result;
60640   return jresult;
60641 }
60642
60643
60644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60645   int jresult ;
60646   int result;
60647
60648   {
60649     try {
60650       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60651     } catch (std::out_of_range& e) {
60652       {
60653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60654       };
60655     } catch (std::exception& e) {
60656       {
60657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60658       };
60659     } catch (Dali::DaliException e) {
60660       {
60661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60662       };
60663     } catch (...) {
60664       {
60665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60666       };
60667     }
60668   }
60669
60670   jresult = (int)result;
60671   return jresult;
60672 }
60673
60674
60675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60676   int jresult ;
60677   int result;
60678
60679   {
60680     try {
60681       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60682     } catch (std::out_of_range& e) {
60683       {
60684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60685       };
60686     } catch (std::exception& e) {
60687       {
60688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60689       };
60690     } catch (Dali::DaliException e) {
60691       {
60692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60693       };
60694     } catch (...) {
60695       {
60696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60697       };
60698     }
60699   }
60700
60701   jresult = (int)result;
60702   return jresult;
60703 }
60704
60705
60706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60707   int jresult ;
60708   int result;
60709
60710   {
60711     try {
60712       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60713     } catch (std::out_of_range& e) {
60714       {
60715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60716       };
60717     } catch (std::exception& e) {
60718       {
60719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60720       };
60721     } catch (Dali::DaliException e) {
60722       {
60723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60724       };
60725     } catch (...) {
60726       {
60727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60728       };
60729     }
60730   }
60731
60732   jresult = (int)result;
60733   return jresult;
60734 }
60735
60736
60737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60738   int jresult ;
60739   int result;
60740
60741   {
60742     try {
60743       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60744     } catch (std::out_of_range& e) {
60745       {
60746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60747       };
60748     } catch (std::exception& e) {
60749       {
60750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60751       };
60752     } catch (Dali::DaliException e) {
60753       {
60754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60755       };
60756     } catch (...) {
60757       {
60758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60759       };
60760     }
60761   }
60762
60763   jresult = (int)result;
60764   return jresult;
60765 }
60766
60767
60768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60769   int jresult ;
60770   int result;
60771
60772   {
60773     try {
60774       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60775     } catch (std::out_of_range& e) {
60776       {
60777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60778       };
60779     } catch (std::exception& e) {
60780       {
60781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60782       };
60783     } catch (Dali::DaliException e) {
60784       {
60785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60786       };
60787     } catch (...) {
60788       {
60789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60790       };
60791     }
60792   }
60793
60794   jresult = (int)result;
60795   return jresult;
60796 }
60797
60798
60799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60800   int jresult ;
60801   int result;
60802
60803   {
60804     try {
60805       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60806     } catch (std::out_of_range& e) {
60807       {
60808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60809       };
60810     } catch (std::exception& e) {
60811       {
60812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60813       };
60814     } catch (Dali::DaliException e) {
60815       {
60816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60817       };
60818     } catch (...) {
60819       {
60820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60821       };
60822     }
60823   }
60824
60825   jresult = (int)result;
60826   return jresult;
60827 }
60828
60829
60830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60831   int jresult ;
60832   int result;
60833
60834   {
60835     try {
60836       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60837     } catch (std::out_of_range& e) {
60838       {
60839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60840       };
60841     } catch (std::exception& e) {
60842       {
60843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60844       };
60845     } catch (Dali::DaliException e) {
60846       {
60847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60848       };
60849     } catch (...) {
60850       {
60851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60852       };
60853     }
60854   }
60855
60856   jresult = (int)result;
60857   return jresult;
60858 }
60859
60860
60861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60862   int jresult ;
60863   int result;
60864
60865   {
60866     try {
60867       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60868     } catch (std::out_of_range& e) {
60869       {
60870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60871       };
60872     } catch (std::exception& e) {
60873       {
60874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60875       };
60876     } catch (Dali::DaliException e) {
60877       {
60878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60879       };
60880     } catch (...) {
60881       {
60882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60883       };
60884     }
60885   }
60886
60887   jresult = (int)result;
60888   return jresult;
60889 }
60890
60891
60892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60893   int jresult ;
60894   int result;
60895
60896   {
60897     try {
60898       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60899     } catch (std::out_of_range& e) {
60900       {
60901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60902       };
60903     } catch (std::exception& e) {
60904       {
60905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60906       };
60907     } catch (Dali::DaliException e) {
60908       {
60909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60910       };
60911     } catch (...) {
60912       {
60913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60914       };
60915     }
60916   }
60917
60918   jresult = (int)result;
60919   return jresult;
60920 }
60921
60922
60923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60924   int jresult ;
60925   int result;
60926
60927   {
60928     try {
60929       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60930     } catch (std::out_of_range& e) {
60931       {
60932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60933       };
60934     } catch (std::exception& e) {
60935       {
60936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60937       };
60938     } catch (Dali::DaliException e) {
60939       {
60940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60941       };
60942     } catch (...) {
60943       {
60944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60945       };
60946     }
60947   }
60948
60949   jresult = (int)result;
60950   return jresult;
60951 }
60952
60953
60954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60955   int jresult ;
60956   int result;
60957
60958   {
60959     try {
60960       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60961     } catch (std::out_of_range& e) {
60962       {
60963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60964       };
60965     } catch (std::exception& e) {
60966       {
60967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60968       };
60969     } catch (Dali::DaliException e) {
60970       {
60971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60972       };
60973     } catch (...) {
60974       {
60975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60976       };
60977     }
60978   }
60979
60980   jresult = (int)result;
60981   return jresult;
60982 }
60983
60984
60985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60986   int jresult ;
60987   int result;
60988
60989   {
60990     try {
60991       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60992     } catch (std::out_of_range& e) {
60993       {
60994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60995       };
60996     } catch (std::exception& e) {
60997       {
60998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60999       };
61000     } catch (Dali::DaliException e) {
61001       {
61002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61003       };
61004     } catch (...) {
61005       {
61006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61007       };
61008     }
61009   }
61010
61011   jresult = (int)result;
61012   return jresult;
61013 }
61014
61015
61016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61017   int jresult ;
61018   int result;
61019
61020   {
61021     try {
61022       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61023     } catch (std::out_of_range& e) {
61024       {
61025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61026       };
61027     } catch (std::exception& e) {
61028       {
61029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61030       };
61031     } catch (Dali::DaliException e) {
61032       {
61033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61034       };
61035     } catch (...) {
61036       {
61037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61038       };
61039     }
61040   }
61041
61042   jresult = (int)result;
61043   return jresult;
61044 }
61045
61046
61047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61048   int jresult ;
61049   int result;
61050
61051   {
61052     try {
61053       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61054     } catch (std::out_of_range& e) {
61055       {
61056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61057       };
61058     } catch (std::exception& e) {
61059       {
61060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61061       };
61062     } catch (Dali::DaliException e) {
61063       {
61064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61065       };
61066     } catch (...) {
61067       {
61068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61069       };
61070     }
61071   }
61072
61073   jresult = (int)result;
61074   return jresult;
61075 }
61076
61077
61078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61079   int jresult ;
61080   int result;
61081
61082   {
61083     try {
61084       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61085     } catch (std::out_of_range& e) {
61086       {
61087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61088       };
61089     } catch (std::exception& e) {
61090       {
61091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61092       };
61093     } catch (Dali::DaliException e) {
61094       {
61095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61096       };
61097     } catch (...) {
61098       {
61099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61100       };
61101     }
61102   }
61103
61104   jresult = (int)result;
61105   return jresult;
61106 }
61107
61108
61109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61110   int jresult ;
61111   int result;
61112
61113   {
61114     try {
61115       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61116     } catch (std::out_of_range& e) {
61117       {
61118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61119       };
61120     } catch (std::exception& e) {
61121       {
61122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61123       };
61124     } catch (Dali::DaliException e) {
61125       {
61126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61127       };
61128     } catch (...) {
61129       {
61130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61131       };
61132     }
61133   }
61134
61135   jresult = (int)result;
61136   return jresult;
61137 }
61138
61139
61140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61141   int jresult ;
61142   int result;
61143
61144   {
61145     try {
61146       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61147     } catch (std::out_of_range& e) {
61148       {
61149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61150       };
61151     } catch (std::exception& e) {
61152       {
61153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61154       };
61155     } catch (Dali::DaliException e) {
61156       {
61157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61158       };
61159     } catch (...) {
61160       {
61161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61162       };
61163     }
61164   }
61165
61166   jresult = (int)result;
61167   return jresult;
61168 }
61169
61170
61171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61172   int jresult ;
61173   int result;
61174
61175   {
61176     try {
61177       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61178     } catch (std::out_of_range& e) {
61179       {
61180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61181       };
61182     } catch (std::exception& e) {
61183       {
61184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61185       };
61186     } catch (Dali::DaliException e) {
61187       {
61188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61189       };
61190     } catch (...) {
61191       {
61192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61193       };
61194     }
61195   }
61196
61197   jresult = (int)result;
61198   return jresult;
61199 }
61200
61201
61202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61203   int jresult ;
61204   int result;
61205
61206   {
61207     try {
61208       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61209     } catch (std::out_of_range& e) {
61210       {
61211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61212       };
61213     } catch (std::exception& e) {
61214       {
61215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61216       };
61217     } catch (Dali::DaliException e) {
61218       {
61219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61220       };
61221     } catch (...) {
61222       {
61223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61224       };
61225     }
61226   }
61227
61228   jresult = (int)result;
61229   return jresult;
61230 }
61231
61232
61233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61234   void * jresult ;
61235   Dali::Toolkit::Builder *result = 0 ;
61236
61237   {
61238     try {
61239       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61240     } catch (std::out_of_range& e) {
61241       {
61242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61243       };
61244     } catch (std::exception& e) {
61245       {
61246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61247       };
61248     } catch (Dali::DaliException e) {
61249       {
61250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61251       };
61252     } catch (...) {
61253       {
61254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61255       };
61256     }
61257   }
61258
61259   jresult = (void *)result;
61260   return jresult;
61261 }
61262
61263
61264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61265   void * jresult ;
61266   Dali::Toolkit::Builder result;
61267
61268   {
61269     try {
61270       result = Dali::Toolkit::Builder::New();
61271     } catch (std::out_of_range& e) {
61272       {
61273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61274       };
61275     } catch (std::exception& e) {
61276       {
61277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61278       };
61279     } catch (Dali::DaliException e) {
61280       {
61281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61282       };
61283     } catch (...) {
61284       {
61285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61286       };
61287     }
61288   }
61289
61290   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61291   return jresult;
61292 }
61293
61294
61295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61296   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61297
61298   arg1 = (Dali::Toolkit::Builder *)jarg1;
61299   {
61300     try {
61301       delete arg1;
61302     } catch (std::out_of_range& e) {
61303       {
61304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61305       };
61306     } catch (std::exception& e) {
61307       {
61308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61309       };
61310     } catch (Dali::DaliException e) {
61311       {
61312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61313       };
61314     } catch (...) {
61315       {
61316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61317       };
61318     }
61319   }
61320
61321 }
61322
61323
61324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61325   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61326   std::string *arg2 = 0 ;
61327   Dali::Toolkit::Builder::UIFormat arg3 ;
61328
61329   arg1 = (Dali::Toolkit::Builder *)jarg1;
61330   if (!jarg2) {
61331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61332     return ;
61333   }
61334   std::string arg2_str(jarg2);
61335   arg2 = &arg2_str;
61336   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61337   {
61338     try {
61339       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61340     } catch (std::out_of_range& e) {
61341       {
61342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61343       };
61344     } catch (std::exception& e) {
61345       {
61346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61347       };
61348     } catch (Dali::DaliException e) {
61349       {
61350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61351       };
61352     } catch (...) {
61353       {
61354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61355       };
61356     }
61357   }
61358
61359
61360   //argout typemap for const std::string&
61361
61362 }
61363
61364
61365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61366   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61367   std::string *arg2 = 0 ;
61368
61369   arg1 = (Dali::Toolkit::Builder *)jarg1;
61370   if (!jarg2) {
61371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61372     return ;
61373   }
61374   std::string arg2_str(jarg2);
61375   arg2 = &arg2_str;
61376   {
61377     try {
61378       (arg1)->LoadFromString((std::string const &)*arg2);
61379     } catch (std::out_of_range& e) {
61380       {
61381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61382       };
61383     } catch (std::exception& e) {
61384       {
61385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61386       };
61387     } catch (Dali::DaliException e) {
61388       {
61389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61390       };
61391     } catch (...) {
61392       {
61393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61394       };
61395     }
61396   }
61397
61398
61399   //argout typemap for const std::string&
61400
61401 }
61402
61403
61404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61405   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61406   Dali::Property::Map *arg2 = 0 ;
61407
61408   arg1 = (Dali::Toolkit::Builder *)jarg1;
61409   arg2 = (Dali::Property::Map *)jarg2;
61410   if (!arg2) {
61411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61412     return ;
61413   }
61414   {
61415     try {
61416       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61417     } catch (std::out_of_range& e) {
61418       {
61419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61420       };
61421     } catch (std::exception& e) {
61422       {
61423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61424       };
61425     } catch (Dali::DaliException e) {
61426       {
61427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61428       };
61429     } catch (...) {
61430       {
61431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61432       };
61433     }
61434   }
61435
61436 }
61437
61438
61439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61440   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61441   std::string *arg2 = 0 ;
61442   Dali::Property::Value *arg3 = 0 ;
61443
61444   arg1 = (Dali::Toolkit::Builder *)jarg1;
61445   if (!jarg2) {
61446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61447     return ;
61448   }
61449   std::string arg2_str(jarg2);
61450   arg2 = &arg2_str;
61451   arg3 = (Dali::Property::Value *)jarg3;
61452   if (!arg3) {
61453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61454     return ;
61455   }
61456   {
61457     try {
61458       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61459     } catch (std::out_of_range& e) {
61460       {
61461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61462       };
61463     } catch (std::exception& e) {
61464       {
61465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61466       };
61467     } catch (Dali::DaliException e) {
61468       {
61469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61470       };
61471     } catch (...) {
61472       {
61473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61474       };
61475     }
61476   }
61477
61478
61479   //argout typemap for const std::string&
61480
61481 }
61482
61483
61484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61485   void * jresult ;
61486   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61487   Dali::Property::Map *result = 0 ;
61488
61489   arg1 = (Dali::Toolkit::Builder *)jarg1;
61490   {
61491     try {
61492       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61493     } catch (std::out_of_range& e) {
61494       {
61495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61496       };
61497     } catch (std::exception& e) {
61498       {
61499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61500       };
61501     } catch (Dali::DaliException e) {
61502       {
61503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61504       };
61505     } catch (...) {
61506       {
61507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61508       };
61509     }
61510   }
61511
61512   jresult = (void *)result;
61513   return jresult;
61514 }
61515
61516
61517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61518   void * jresult ;
61519   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61520   std::string *arg2 = 0 ;
61521   Dali::Property::Value *result = 0 ;
61522
61523   arg1 = (Dali::Toolkit::Builder *)jarg1;
61524   if (!jarg2) {
61525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61526     return 0;
61527   }
61528   std::string arg2_str(jarg2);
61529   arg2 = &arg2_str;
61530   {
61531     try {
61532       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61533     } catch (std::out_of_range& e) {
61534       {
61535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61536       };
61537     } catch (std::exception& e) {
61538       {
61539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61540       };
61541     } catch (Dali::DaliException e) {
61542       {
61543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61544       };
61545     } catch (...) {
61546       {
61547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61548       };
61549     }
61550   }
61551
61552   jresult = (void *)result;
61553
61554   //argout typemap for const std::string&
61555
61556   return jresult;
61557 }
61558
61559
61560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61561   void * jresult ;
61562   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61563   std::string *arg2 = 0 ;
61564   Dali::Animation result;
61565
61566   arg1 = (Dali::Toolkit::Builder *)jarg1;
61567   if (!jarg2) {
61568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61569     return 0;
61570   }
61571   std::string arg2_str(jarg2);
61572   arg2 = &arg2_str;
61573   {
61574     try {
61575       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61576     } catch (std::out_of_range& e) {
61577       {
61578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61579       };
61580     } catch (std::exception& e) {
61581       {
61582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61583       };
61584     } catch (Dali::DaliException e) {
61585       {
61586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61587       };
61588     } catch (...) {
61589       {
61590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61591       };
61592     }
61593   }
61594
61595   jresult = new Dali::Animation((const Dali::Animation &)result);
61596
61597   //argout typemap for const std::string&
61598
61599   return jresult;
61600 }
61601
61602
61603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61604   void * jresult ;
61605   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61606   std::string *arg2 = 0 ;
61607   Dali::Property::Map *arg3 = 0 ;
61608   Dali::Animation result;
61609
61610   arg1 = (Dali::Toolkit::Builder *)jarg1;
61611   if (!jarg2) {
61612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61613     return 0;
61614   }
61615   std::string arg2_str(jarg2);
61616   arg2 = &arg2_str;
61617   arg3 = (Dali::Property::Map *)jarg3;
61618   if (!arg3) {
61619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61620     return 0;
61621   }
61622   {
61623     try {
61624       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61625     } catch (std::out_of_range& e) {
61626       {
61627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61628       };
61629     } catch (std::exception& e) {
61630       {
61631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61632       };
61633     } catch (Dali::DaliException e) {
61634       {
61635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61636       };
61637     } catch (...) {
61638       {
61639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61640       };
61641     }
61642   }
61643
61644   jresult = new Dali::Animation((const Dali::Animation &)result);
61645
61646   //argout typemap for const std::string&
61647
61648   return jresult;
61649 }
61650
61651
61652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61653   void * jresult ;
61654   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61655   std::string *arg2 = 0 ;
61656   Dali::Actor arg3 ;
61657   Dali::Actor *argp3 ;
61658   Dali::Animation result;
61659
61660   arg1 = (Dali::Toolkit::Builder *)jarg1;
61661   if (!jarg2) {
61662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61663     return 0;
61664   }
61665   std::string arg2_str(jarg2);
61666   arg2 = &arg2_str;
61667   argp3 = (Dali::Actor *)jarg3;
61668   if (!argp3) {
61669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61670     return 0;
61671   }
61672   arg3 = *argp3;
61673   {
61674     try {
61675       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61676     } catch (std::out_of_range& e) {
61677       {
61678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61679       };
61680     } catch (std::exception& e) {
61681       {
61682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61683       };
61684     } catch (Dali::DaliException e) {
61685       {
61686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61687       };
61688     } catch (...) {
61689       {
61690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61691       };
61692     }
61693   }
61694
61695   jresult = new Dali::Animation((const Dali::Animation &)result);
61696
61697   //argout typemap for const std::string&
61698
61699   return jresult;
61700 }
61701
61702
61703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61704   void * jresult ;
61705   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61706   std::string *arg2 = 0 ;
61707   Dali::Property::Map *arg3 = 0 ;
61708   Dali::Actor arg4 ;
61709   Dali::Actor *argp4 ;
61710   Dali::Animation result;
61711
61712   arg1 = (Dali::Toolkit::Builder *)jarg1;
61713   if (!jarg2) {
61714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61715     return 0;
61716   }
61717   std::string arg2_str(jarg2);
61718   arg2 = &arg2_str;
61719   arg3 = (Dali::Property::Map *)jarg3;
61720   if (!arg3) {
61721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61722     return 0;
61723   }
61724   argp4 = (Dali::Actor *)jarg4;
61725   if (!argp4) {
61726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61727     return 0;
61728   }
61729   arg4 = *argp4;
61730   {
61731     try {
61732       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61733     } catch (std::out_of_range& e) {
61734       {
61735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61736       };
61737     } catch (std::exception& e) {
61738       {
61739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61740       };
61741     } catch (Dali::DaliException e) {
61742       {
61743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61744       };
61745     } catch (...) {
61746       {
61747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61748       };
61749     }
61750   }
61751
61752   jresult = new Dali::Animation((const Dali::Animation &)result);
61753
61754   //argout typemap for const std::string&
61755
61756   return jresult;
61757 }
61758
61759
61760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61761   void * jresult ;
61762   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61763   std::string *arg2 = 0 ;
61764   Dali::BaseHandle result;
61765
61766   arg1 = (Dali::Toolkit::Builder *)jarg1;
61767   if (!jarg2) {
61768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61769     return 0;
61770   }
61771   std::string arg2_str(jarg2);
61772   arg2 = &arg2_str;
61773   {
61774     try {
61775       result = (arg1)->Create((std::string const &)*arg2);
61776     } catch (std::out_of_range& e) {
61777       {
61778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61779       };
61780     } catch (std::exception& e) {
61781       {
61782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61783       };
61784     } catch (Dali::DaliException e) {
61785       {
61786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61787       };
61788     } catch (...) {
61789       {
61790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61791       };
61792     }
61793   }
61794
61795   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61796
61797   //argout typemap for const std::string&
61798
61799   return jresult;
61800 }
61801
61802
61803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61804   void * jresult ;
61805   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61806   std::string *arg2 = 0 ;
61807   Dali::Property::Map *arg3 = 0 ;
61808   Dali::BaseHandle result;
61809
61810   arg1 = (Dali::Toolkit::Builder *)jarg1;
61811   if (!jarg2) {
61812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61813     return 0;
61814   }
61815   std::string arg2_str(jarg2);
61816   arg2 = &arg2_str;
61817   arg3 = (Dali::Property::Map *)jarg3;
61818   if (!arg3) {
61819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61820     return 0;
61821   }
61822   {
61823     try {
61824       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61825     } catch (std::out_of_range& e) {
61826       {
61827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61828       };
61829     } catch (std::exception& e) {
61830       {
61831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61832       };
61833     } catch (Dali::DaliException e) {
61834       {
61835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61836       };
61837     } catch (...) {
61838       {
61839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61840       };
61841     }
61842   }
61843
61844   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61845
61846   //argout typemap for const std::string&
61847
61848   return jresult;
61849 }
61850
61851
61852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61853   void * jresult ;
61854   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61855   std::string *arg2 = 0 ;
61856   Dali::BaseHandle result;
61857
61858   arg1 = (Dali::Toolkit::Builder *)jarg1;
61859   if (!jarg2) {
61860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61861     return 0;
61862   }
61863   std::string arg2_str(jarg2);
61864   arg2 = &arg2_str;
61865   {
61866     try {
61867       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61868     } catch (std::out_of_range& e) {
61869       {
61870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61871       };
61872     } catch (std::exception& e) {
61873       {
61874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61875       };
61876     } catch (Dali::DaliException e) {
61877       {
61878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61879       };
61880     } catch (...) {
61881       {
61882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61883       };
61884     }
61885   }
61886
61887   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61888
61889   //argout typemap for const std::string&
61890
61891   return jresult;
61892 }
61893
61894
61895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61896   unsigned int jresult ;
61897   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61898   std::string *arg2 = 0 ;
61899   Dali::Handle *arg3 = 0 ;
61900   bool result;
61901
61902   arg1 = (Dali::Toolkit::Builder *)jarg1;
61903   if (!jarg2) {
61904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61905     return 0;
61906   }
61907   std::string arg2_str(jarg2);
61908   arg2 = &arg2_str;
61909   arg3 = (Dali::Handle *)jarg3;
61910   if (!arg3) {
61911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61912     return 0;
61913   }
61914   {
61915     try {
61916       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61917     } catch (std::out_of_range& e) {
61918       {
61919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61920       };
61921     } catch (std::exception& e) {
61922       {
61923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61924       };
61925     } catch (Dali::DaliException e) {
61926       {
61927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61928       };
61929     } catch (...) {
61930       {
61931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61932       };
61933     }
61934   }
61935
61936   jresult = result;
61937
61938   //argout typemap for const std::string&
61939
61940   return jresult;
61941 }
61942
61943
61944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61945   unsigned int jresult ;
61946   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61947   Dali::Handle *arg2 = 0 ;
61948   std::string *arg3 = 0 ;
61949   bool result;
61950
61951   arg1 = (Dali::Toolkit::Builder *)jarg1;
61952   arg2 = (Dali::Handle *)jarg2;
61953   if (!arg2) {
61954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61955     return 0;
61956   }
61957   if (!jarg3) {
61958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61959     return 0;
61960   }
61961   std::string arg3_str(jarg3);
61962   arg3 = &arg3_str;
61963   {
61964     try {
61965       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61966     } catch (std::out_of_range& e) {
61967       {
61968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61969       };
61970     } catch (std::exception& e) {
61971       {
61972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61973       };
61974     } catch (Dali::DaliException e) {
61975       {
61976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61977       };
61978     } catch (...) {
61979       {
61980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61981       };
61982     }
61983   }
61984
61985   jresult = result;
61986
61987   //argout typemap for const std::string&
61988
61989   return jresult;
61990 }
61991
61992
61993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61994   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61995   Dali::Actor arg2 ;
61996   Dali::Actor *argp2 ;
61997
61998   arg1 = (Dali::Toolkit::Builder *)jarg1;
61999   argp2 = (Dali::Actor *)jarg2;
62000   if (!argp2) {
62001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62002     return ;
62003   }
62004   arg2 = *argp2;
62005   {
62006     try {
62007       (arg1)->AddActors(arg2);
62008     } catch (std::out_of_range& e) {
62009       {
62010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62011       };
62012     } catch (std::exception& e) {
62013       {
62014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62015       };
62016     } catch (Dali::DaliException e) {
62017       {
62018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62019       };
62020     } catch (...) {
62021       {
62022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62023       };
62024     }
62025   }
62026
62027 }
62028
62029
62030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62031   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62032   std::string *arg2 = 0 ;
62033   Dali::Actor arg3 ;
62034   Dali::Actor *argp3 ;
62035
62036   arg1 = (Dali::Toolkit::Builder *)jarg1;
62037   if (!jarg2) {
62038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62039     return ;
62040   }
62041   std::string arg2_str(jarg2);
62042   arg2 = &arg2_str;
62043   argp3 = (Dali::Actor *)jarg3;
62044   if (!argp3) {
62045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62046     return ;
62047   }
62048   arg3 = *argp3;
62049   {
62050     try {
62051       (arg1)->AddActors((std::string const &)*arg2,arg3);
62052     } catch (std::out_of_range& e) {
62053       {
62054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62055       };
62056     } catch (std::exception& e) {
62057       {
62058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62059       };
62060     } catch (Dali::DaliException e) {
62061       {
62062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62063       };
62064     } catch (...) {
62065       {
62066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62067       };
62068     }
62069   }
62070
62071
62072   //argout typemap for const std::string&
62073
62074 }
62075
62076
62077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62078   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62079   std::string *arg2 = 0 ;
62080
62081   arg1 = (Dali::Toolkit::Builder *)jarg1;
62082   if (!jarg2) {
62083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62084     return ;
62085   }
62086   std::string arg2_str(jarg2);
62087   arg2 = &arg2_str;
62088   {
62089     try {
62090       (arg1)->CreateRenderTask((std::string const &)*arg2);
62091     } catch (std::out_of_range& e) {
62092       {
62093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62094       };
62095     } catch (std::exception& e) {
62096       {
62097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62098       };
62099     } catch (Dali::DaliException e) {
62100       {
62101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62102       };
62103     } catch (...) {
62104       {
62105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62106       };
62107     }
62108   }
62109
62110
62111   //argout typemap for const std::string&
62112
62113 }
62114
62115
62116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62117   void * jresult ;
62118   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62119   std::string *arg2 = 0 ;
62120   Dali::Path result;
62121
62122   arg1 = (Dali::Toolkit::Builder *)jarg1;
62123   if (!jarg2) {
62124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62125     return 0;
62126   }
62127   std::string arg2_str(jarg2);
62128   arg2 = &arg2_str;
62129   {
62130     try {
62131       result = (arg1)->GetPath((std::string const &)*arg2);
62132     } catch (std::out_of_range& e) {
62133       {
62134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62135       };
62136     } catch (std::exception& e) {
62137       {
62138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62139       };
62140     } catch (Dali::DaliException e) {
62141       {
62142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62143       };
62144     } catch (...) {
62145       {
62146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62147       };
62148     }
62149   }
62150
62151   jresult = new Dali::Path((const Dali::Path &)result);
62152
62153   //argout typemap for const std::string&
62154
62155   return jresult;
62156 }
62157
62158
62159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62160   void * jresult ;
62161   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62162   std::string *arg2 = 0 ;
62163   Dali::PathConstrainer result;
62164
62165   arg1 = (Dali::Toolkit::Builder *)jarg1;
62166   if (!jarg2) {
62167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62168     return 0;
62169   }
62170   std::string arg2_str(jarg2);
62171   arg2 = &arg2_str;
62172   {
62173     try {
62174       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62175     } catch (std::out_of_range& e) {
62176       {
62177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62178       };
62179     } catch (std::exception& e) {
62180       {
62181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62182       };
62183     } catch (Dali::DaliException e) {
62184       {
62185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62186       };
62187     } catch (...) {
62188       {
62189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62190       };
62191     }
62192   }
62193
62194   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62195
62196   //argout typemap for const std::string&
62197
62198   return jresult;
62199 }
62200
62201
62202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62203   void * jresult ;
62204   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62205   std::string *arg2 = 0 ;
62206   Dali::LinearConstrainer result;
62207
62208   arg1 = (Dali::Toolkit::Builder *)jarg1;
62209   if (!jarg2) {
62210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62211     return 0;
62212   }
62213   std::string arg2_str(jarg2);
62214   arg2 = &arg2_str;
62215   {
62216     try {
62217       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62218     } catch (std::out_of_range& e) {
62219       {
62220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62221       };
62222     } catch (std::exception& e) {
62223       {
62224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62225       };
62226     } catch (Dali::DaliException e) {
62227       {
62228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62229       };
62230     } catch (...) {
62231       {
62232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62233       };
62234     }
62235   }
62236
62237   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62238
62239   //argout typemap for const std::string&
62240
62241   return jresult;
62242 }
62243
62244
62245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62246   void * jresult ;
62247   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62248   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62249
62250   arg1 = (Dali::Toolkit::Builder *)jarg1;
62251   {
62252     try {
62253       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62254     } catch (std::out_of_range& e) {
62255       {
62256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62257       };
62258     } catch (std::exception& e) {
62259       {
62260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62261       };
62262     } catch (Dali::DaliException e) {
62263       {
62264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62265       };
62266     } catch (...) {
62267       {
62268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62269       };
62270     }
62271   }
62272
62273   jresult = (void *)result;
62274   return jresult;
62275 }
62276
62277
62278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62279   void * jresult ;
62280   Dali::Toolkit::TransitionData *result = 0 ;
62281
62282   {
62283     try {
62284       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62285     } catch (std::out_of_range& e) {
62286       {
62287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62288       };
62289     } catch (std::exception& e) {
62290       {
62291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62292       };
62293     } catch (Dali::DaliException e) {
62294       {
62295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62296       };
62297     } catch (...) {
62298       {
62299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62300       };
62301     }
62302   }
62303
62304   jresult = (void *)result;
62305   return jresult;
62306 }
62307
62308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62309   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62310
62311   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62312   {
62313     try {
62314       delete arg1;
62315     } catch (std::out_of_range& e) {
62316       {
62317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62318       };
62319     } catch (std::exception& e) {
62320       {
62321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62322       };
62323     } catch (Dali::DaliException e) {
62324       {
62325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62326       };
62327     } catch (...) {
62328       {
62329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62330       };
62331     }
62332   }
62333
62334 }
62335
62336
62337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62338   void * jresult ;
62339   Dali::Property::Map *arg1 = 0 ;
62340   Dali::Toolkit::TransitionData result;
62341
62342   arg1 = (Dali::Property::Map *)jarg1;
62343   if (!arg1) {
62344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62345     return 0;
62346   }
62347   {
62348     try {
62349       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62350     } catch (std::out_of_range& e) {
62351       {
62352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62353       };
62354     } catch (std::exception& e) {
62355       {
62356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62357       };
62358     } catch (Dali::DaliException e) {
62359       {
62360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62361       };
62362     } catch (...) {
62363       {
62364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62365       };
62366     }
62367   }
62368
62369   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62370   return jresult;
62371 }
62372
62373
62374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62375   void * jresult ;
62376   Dali::Property::Array *arg1 = 0 ;
62377   Dali::Toolkit::TransitionData result;
62378
62379   arg1 = (Dali::Property::Array *)jarg1;
62380   if (!arg1) {
62381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62382     return 0;
62383   }
62384   {
62385     try {
62386       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62387     } catch (std::out_of_range& e) {
62388       {
62389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62390       };
62391     } catch (std::exception& e) {
62392       {
62393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62394       };
62395     } catch (Dali::DaliException e) {
62396       {
62397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62398       };
62399     } catch (...) {
62400       {
62401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62402       };
62403     }
62404   }
62405
62406   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62407   return jresult;
62408 }
62409
62410
62411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62412   void * jresult ;
62413   Dali::BaseHandle arg1 ;
62414   Dali::BaseHandle *argp1 ;
62415   Dali::Toolkit::TransitionData result;
62416
62417   argp1 = (Dali::BaseHandle *)jarg1;
62418   if (!argp1) {
62419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62420     return 0;
62421   }
62422   arg1 = *argp1;
62423   {
62424     try {
62425       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62426     } catch (std::out_of_range& e) {
62427       {
62428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62429       };
62430     } catch (std::exception& e) {
62431       {
62432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62433       };
62434     } catch (Dali::DaliException e) {
62435       {
62436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62437       };
62438     } catch (...) {
62439       {
62440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62441       };
62442     }
62443   }
62444
62445   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62446   return jresult;
62447 }
62448
62449
62450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62451   void * jresult ;
62452   Dali::Toolkit::TransitionData *arg1 = 0 ;
62453   Dali::Toolkit::TransitionData *result = 0 ;
62454
62455   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62456   if (!arg1) {
62457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62458     return 0;
62459   }
62460   {
62461     try {
62462       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62463     } catch (std::out_of_range& e) {
62464       {
62465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62466       };
62467     } catch (std::exception& e) {
62468       {
62469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62470       };
62471     } catch (Dali::DaliException e) {
62472       {
62473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62474       };
62475     } catch (...) {
62476       {
62477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62478       };
62479     }
62480   }
62481
62482   jresult = (void *)result;
62483   return jresult;
62484 }
62485
62486
62487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62488   void * jresult ;
62489   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62490   Dali::Toolkit::TransitionData *arg2 = 0 ;
62491   Dali::Toolkit::TransitionData *result = 0 ;
62492
62493   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62494   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62495   if (!arg2) {
62496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62497     return 0;
62498   }
62499   {
62500     try {
62501       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62502     } catch (std::out_of_range& e) {
62503       {
62504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62505       };
62506     } catch (std::exception& e) {
62507       {
62508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62509       };
62510     } catch (Dali::DaliException e) {
62511       {
62512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62513       };
62514     } catch (...) {
62515       {
62516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62517       };
62518     }
62519   }
62520
62521   jresult = (void *)result;
62522   return jresult;
62523 }
62524
62525
62526 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62527   unsigned long jresult ;
62528   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62529   size_t result;
62530
62531   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62532   {
62533     try {
62534       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62535     } catch (std::out_of_range& e) {
62536       {
62537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62538       };
62539     } catch (std::exception& e) {
62540       {
62541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62542       };
62543     } catch (Dali::DaliException e) {
62544       {
62545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62546       };
62547     } catch (...) {
62548       {
62549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62550       };
62551     }
62552   }
62553
62554   jresult = (unsigned long)result;
62555   return jresult;
62556 }
62557
62558
62559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62560   void * jresult ;
62561   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62562   size_t arg2 ;
62563   Dali::Property::Map result;
62564
62565   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62566   arg2 = (size_t)jarg2;
62567   {
62568     try {
62569       result = (arg1)->GetAnimatorAt(arg2);
62570     } catch (std::out_of_range& e) {
62571       {
62572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62573       };
62574     } catch (std::exception& e) {
62575       {
62576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62577       };
62578     } catch (Dali::DaliException e) {
62579       {
62580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62581       };
62582     } catch (...) {
62583       {
62584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62585       };
62586     }
62587   }
62588
62589   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62590   return jresult;
62591 }
62592
62593
62594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62595   int jresult ;
62596   int result;
62597
62598   {
62599     try {
62600       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62601     } catch (std::out_of_range& e) {
62602       {
62603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62604       };
62605     } catch (std::exception& e) {
62606       {
62607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62608       };
62609     } catch (Dali::DaliException e) {
62610       {
62611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62612       };
62613     } catch (...) {
62614       {
62615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62616       };
62617     }
62618   }
62619
62620   jresult = (int)result;
62621   return jresult;
62622 }
62623
62624
62625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62626   int jresult ;
62627   int result;
62628
62629   {
62630     try {
62631       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62632     } catch (std::out_of_range& e) {
62633       {
62634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62635       };
62636     } catch (std::exception& e) {
62637       {
62638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62639       };
62640     } catch (Dali::DaliException e) {
62641       {
62642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62643       };
62644     } catch (...) {
62645       {
62646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62647       };
62648     }
62649   }
62650
62651   jresult = (int)result;
62652   return jresult;
62653 }
62654
62655
62656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62657   int jresult ;
62658   int result;
62659
62660   {
62661     try {
62662       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62663     } catch (std::out_of_range& e) {
62664       {
62665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62666       };
62667     } catch (std::exception& e) {
62668       {
62669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62670       };
62671     } catch (Dali::DaliException e) {
62672       {
62673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62674       };
62675     } catch (...) {
62676       {
62677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62678       };
62679     }
62680   }
62681
62682   jresult = (int)result;
62683   return jresult;
62684 }
62685
62686
62687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62688   int jresult ;
62689   int result;
62690
62691   {
62692     try {
62693       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62694     } catch (std::out_of_range& e) {
62695       {
62696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62697       };
62698     } catch (std::exception& e) {
62699       {
62700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62701       };
62702     } catch (Dali::DaliException e) {
62703       {
62704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62705       };
62706     } catch (...) {
62707       {
62708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62709       };
62710     }
62711   }
62712
62713   jresult = (int)result;
62714   return jresult;
62715 }
62716
62717
62718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62719   int jresult ;
62720   int result;
62721
62722   {
62723     try {
62724       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62725     } catch (std::out_of_range& e) {
62726       {
62727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62728       };
62729     } catch (std::exception& e) {
62730       {
62731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62732       };
62733     } catch (Dali::DaliException e) {
62734       {
62735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62736       };
62737     } catch (...) {
62738       {
62739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62740       };
62741     }
62742   }
62743
62744   jresult = (int)result;
62745   return jresult;
62746 }
62747
62748
62749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62750   int jresult ;
62751   int result;
62752
62753   {
62754     try {
62755       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62756     } catch (std::out_of_range& e) {
62757       {
62758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62759       };
62760     } catch (std::exception& e) {
62761       {
62762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62763       };
62764     } catch (Dali::DaliException e) {
62765       {
62766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62767       };
62768     } catch (...) {
62769       {
62770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62771       };
62772     }
62773   }
62774
62775   jresult = (int)result;
62776   return jresult;
62777 }
62778
62779
62780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62781   int jresult ;
62782   int result;
62783
62784   {
62785     try {
62786       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62787     } catch (std::out_of_range& e) {
62788       {
62789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62790       };
62791     } catch (std::exception& e) {
62792       {
62793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62794       };
62795     } catch (Dali::DaliException e) {
62796       {
62797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62798       };
62799     } catch (...) {
62800       {
62801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62802       };
62803     }
62804   }
62805
62806   jresult = (int)result;
62807   return jresult;
62808 }
62809
62810
62811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62812   int jresult ;
62813   int result;
62814
62815   {
62816     try {
62817       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62818     } catch (std::out_of_range& e) {
62819       {
62820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62821       };
62822     } catch (std::exception& e) {
62823       {
62824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62825       };
62826     } catch (Dali::DaliException e) {
62827       {
62828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62829       };
62830     } catch (...) {
62831       {
62832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62833       };
62834     }
62835   }
62836
62837   jresult = (int)result;
62838   return jresult;
62839 }
62840
62841
62842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62843   int jresult ;
62844   int result;
62845
62846   {
62847     try {
62848       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62849     } catch (std::out_of_range& e) {
62850       {
62851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62852       };
62853     } catch (std::exception& e) {
62854       {
62855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62856       };
62857     } catch (Dali::DaliException e) {
62858       {
62859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62860       };
62861     } catch (...) {
62862       {
62863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62864       };
62865     }
62866   }
62867
62868   jresult = (int)result;
62869   return jresult;
62870 }
62871
62872
62873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62874   int jresult ;
62875   int result;
62876
62877   {
62878     try {
62879       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62880     } catch (std::out_of_range& e) {
62881       {
62882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62883       };
62884     } catch (std::exception& e) {
62885       {
62886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62887       };
62888     } catch (Dali::DaliException e) {
62889       {
62890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62891       };
62892     } catch (...) {
62893       {
62894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62895       };
62896     }
62897   }
62898
62899   jresult = (int)result;
62900   return jresult;
62901 }
62902
62903
62904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62905   int jresult ;
62906   int result;
62907
62908   {
62909     try {
62910       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62911     } catch (std::out_of_range& e) {
62912       {
62913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62914       };
62915     } catch (std::exception& e) {
62916       {
62917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62918       };
62919     } catch (Dali::DaliException e) {
62920       {
62921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62922       };
62923     } catch (...) {
62924       {
62925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62926       };
62927     }
62928   }
62929
62930   jresult = (int)result;
62931   return jresult;
62932 }
62933
62934
62935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62936   int jresult ;
62937   int result;
62938
62939   {
62940     try {
62941       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62942     } catch (std::out_of_range& e) {
62943       {
62944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62945       };
62946     } catch (std::exception& e) {
62947       {
62948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62949       };
62950     } catch (Dali::DaliException e) {
62951       {
62952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62953       };
62954     } catch (...) {
62955       {
62956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62957       };
62958     }
62959   }
62960
62961   jresult = (int)result;
62962   return jresult;
62963 }
62964
62965
62966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62967   int jresult ;
62968   int result;
62969
62970   {
62971     try {
62972       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62973     } catch (std::out_of_range& e) {
62974       {
62975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62976       };
62977     } catch (std::exception& e) {
62978       {
62979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62980       };
62981     } catch (Dali::DaliException e) {
62982       {
62983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62984       };
62985     } catch (...) {
62986       {
62987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62988       };
62989     }
62990   }
62991
62992   jresult = (int)result;
62993   return jresult;
62994 }
62995
62996
62997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62998   int jresult ;
62999   int result;
63000
63001   {
63002     try {
63003       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63004     } catch (std::out_of_range& e) {
63005       {
63006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63007       };
63008     } catch (std::exception& e) {
63009       {
63010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63011       };
63012     } catch (Dali::DaliException e) {
63013       {
63014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63015       };
63016     } catch (...) {
63017       {
63018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63019       };
63020     }
63021   }
63022
63023   jresult = (int)result;
63024   return jresult;
63025 }
63026
63027
63028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63029   void * jresult ;
63030   Dali::Toolkit::Control result;
63031
63032   {
63033     try {
63034       result = Dali::Toolkit::Internal::Control::New();
63035     } catch (std::out_of_range& e) {
63036       {
63037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63038       };
63039     } catch (std::exception& e) {
63040       {
63041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63042       };
63043     } catch (Dali::DaliException e) {
63044       {
63045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63046       };
63047     } catch (...) {
63048       {
63049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63050       };
63051     }
63052   }
63053
63054   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63055   return jresult;
63056 }
63057
63058
63059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63060   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63061   std::string *arg2 = 0 ;
63062
63063   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63064   if (!jarg2) {
63065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63066     return ;
63067   }
63068   std::string arg2_str(jarg2);
63069   arg2 = &arg2_str;
63070   {
63071     try {
63072       (arg1)->SetStyleName((std::string const &)*arg2);
63073     } catch (std::out_of_range& e) {
63074       {
63075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63076       };
63077     } catch (std::exception& e) {
63078       {
63079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63080       };
63081     } catch (Dali::DaliException e) {
63082       {
63083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63084       };
63085     } catch (...) {
63086       {
63087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63088       };
63089     }
63090   }
63091
63092
63093   //argout typemap for const std::string&
63094
63095 }
63096
63097
63098 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63099   char * jresult ;
63100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63101   std::string *result = 0 ;
63102
63103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63104   {
63105     try {
63106       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63107     } catch (std::out_of_range& e) {
63108       {
63109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63110       };
63111     } catch (std::exception& e) {
63112       {
63113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63114       };
63115     } catch (Dali::DaliException e) {
63116       {
63117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63118       };
63119     } catch (...) {
63120       {
63121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63122       };
63123     }
63124   }
63125
63126   jresult = SWIG_csharp_string_callback(result->c_str());
63127   return jresult;
63128 }
63129
63130
63131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63133   Dali::Vector4 *arg2 = 0 ;
63134
63135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63136   arg2 = (Dali::Vector4 *)jarg2;
63137   if (!arg2) {
63138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63139     return ;
63140   }
63141   {
63142     try {
63143       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63144     } catch (std::out_of_range& e) {
63145       {
63146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63147       };
63148     } catch (std::exception& e) {
63149       {
63150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63151       };
63152     } catch (Dali::DaliException e) {
63153       {
63154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63155       };
63156     } catch (...) {
63157       {
63158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63159       };
63160     }
63161   }
63162
63163 }
63164
63165
63166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63167   void * jresult ;
63168   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
63169   Dali::Vector4 result;
63170
63171   arg1 = (Dali::Handle *)jarg1;
63172   {
63173     try {
63174       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
63175       if (resultMap)
63176       {
63177         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
63178         if(type && type->Get<int>() == Visual::COLOR )
63179         {
63180           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
63181           if (value)
63182           {
63183             result = value->Get<Vector4>();
63184           }
63185         }
63186       }
63187     } catch (std::out_of_range& e) {
63188       {
63189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63190       };
63191     } catch (std::exception& e) {
63192       {
63193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63194       };
63195     } catch (Dali::DaliException e) {
63196       {
63197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63198       };
63199     } catch (...) {
63200       {
63201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63202       };
63203     }
63204   }
63205
63206   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63207   return jresult;
63208 }
63209
63210
63211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63213   Dali::Property::Map *arg2 = 0 ;
63214
63215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63216   arg2 = (Dali::Property::Map *)jarg2;
63217   if (!arg2) {
63218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63219     return ;
63220   }
63221   {
63222     try {
63223       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63224     } catch (std::out_of_range& e) {
63225       {
63226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63227       };
63228     } catch (std::exception& e) {
63229       {
63230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63231       };
63232     } catch (Dali::DaliException e) {
63233       {
63234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63235       };
63236     } catch (...) {
63237       {
63238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63239       };
63240     }
63241   }
63242
63243 }
63244
63245
63246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63247   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63248
63249   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63250   {
63251     try {
63252       (arg1)->ClearBackground();
63253     } catch (std::out_of_range& e) {
63254       {
63255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63256       };
63257     } catch (std::exception& e) {
63258       {
63259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63260       };
63261     } catch (Dali::DaliException e) {
63262       {
63263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63264       };
63265     } catch (...) {
63266       {
63267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63268       };
63269     }
63270   }
63271
63272 }
63273
63274
63275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63277   Dali::Gesture::Type arg2 ;
63278
63279   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63280   arg2 = (Dali::Gesture::Type)jarg2;
63281   {
63282     try {
63283       (arg1)->EnableGestureDetection(arg2);
63284     } catch (std::out_of_range& e) {
63285       {
63286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63287       };
63288     } catch (std::exception& e) {
63289       {
63290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63291       };
63292     } catch (Dali::DaliException e) {
63293       {
63294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63295       };
63296     } catch (...) {
63297       {
63298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63299       };
63300     }
63301   }
63302
63303 }
63304
63305
63306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63307   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63308   Dali::Gesture::Type arg2 ;
63309
63310   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63311   arg2 = (Dali::Gesture::Type)jarg2;
63312   {
63313     try {
63314       (arg1)->DisableGestureDetection(arg2);
63315     } catch (std::out_of_range& e) {
63316       {
63317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63318       };
63319     } catch (std::exception& e) {
63320       {
63321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63322       };
63323     } catch (Dali::DaliException e) {
63324       {
63325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63326       };
63327     } catch (...) {
63328       {
63329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63330       };
63331     }
63332   }
63333
63334 }
63335
63336
63337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63338   void * jresult ;
63339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63340   Dali::PinchGestureDetector result;
63341
63342   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63343   {
63344     try {
63345       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63346     } catch (std::out_of_range& e) {
63347       {
63348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63349       };
63350     } catch (std::exception& e) {
63351       {
63352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63353       };
63354     } catch (Dali::DaliException e) {
63355       {
63356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63357       };
63358     } catch (...) {
63359       {
63360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63361       };
63362     }
63363   }
63364
63365   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63366   return jresult;
63367 }
63368
63369
63370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63371   void * jresult ;
63372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63373   Dali::PanGestureDetector result;
63374
63375   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63376   {
63377     try {
63378       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63379     } catch (std::out_of_range& e) {
63380       {
63381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63382       };
63383     } catch (std::exception& e) {
63384       {
63385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63386       };
63387     } catch (Dali::DaliException e) {
63388       {
63389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63390       };
63391     } catch (...) {
63392       {
63393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63394       };
63395     }
63396   }
63397
63398   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63399   return jresult;
63400 }
63401
63402
63403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63404   void * jresult ;
63405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63406   Dali::TapGestureDetector result;
63407
63408   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63409   {
63410     try {
63411       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63412     } catch (std::out_of_range& e) {
63413       {
63414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63415       };
63416     } catch (std::exception& e) {
63417       {
63418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63419       };
63420     } catch (Dali::DaliException e) {
63421       {
63422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63423       };
63424     } catch (...) {
63425       {
63426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63427       };
63428     }
63429   }
63430
63431   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63432   return jresult;
63433 }
63434
63435
63436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63437   void * jresult ;
63438   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63439   Dali::LongPressGestureDetector result;
63440
63441   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63442   {
63443     try {
63444       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63445     } catch (std::out_of_range& e) {
63446       {
63447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63448       };
63449     } catch (std::exception& e) {
63450       {
63451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63452       };
63453     } catch (Dali::DaliException e) {
63454       {
63455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63456       };
63457     } catch (...) {
63458       {
63459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63460       };
63461     }
63462   }
63463
63464   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63465   return jresult;
63466 }
63467
63468
63469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63470   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63471   bool arg2 ;
63472
63473   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63474   arg2 = jarg2 ? true : false;
63475   {
63476     try {
63477       (arg1)->SetKeyboardNavigationSupport(arg2);
63478     } catch (std::out_of_range& e) {
63479       {
63480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63481       };
63482     } catch (std::exception& e) {
63483       {
63484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63485       };
63486     } catch (Dali::DaliException e) {
63487       {
63488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63489       };
63490     } catch (...) {
63491       {
63492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63493       };
63494     }
63495   }
63496
63497 }
63498
63499
63500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63501   unsigned int jresult ;
63502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63503   bool result;
63504
63505   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63506   {
63507     try {
63508       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63509     } catch (std::out_of_range& e) {
63510       {
63511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63512       };
63513     } catch (std::exception& e) {
63514       {
63515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63516       };
63517     } catch (Dali::DaliException e) {
63518       {
63519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63520       };
63521     } catch (...) {
63522       {
63523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63524       };
63525     }
63526   }
63527
63528   jresult = result;
63529   return jresult;
63530 }
63531
63532
63533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63535
63536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63537   {
63538     try {
63539       (arg1)->SetKeyInputFocus();
63540     } catch (std::out_of_range& e) {
63541       {
63542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63543       };
63544     } catch (std::exception& e) {
63545       {
63546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63547       };
63548     } catch (Dali::DaliException e) {
63549       {
63550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63551       };
63552     } catch (...) {
63553       {
63554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63555       };
63556     }
63557   }
63558
63559 }
63560
63561
63562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63563   unsigned int jresult ;
63564   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63565   bool result;
63566
63567   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63568   {
63569     try {
63570       result = (bool)(arg1)->HasKeyInputFocus();
63571     } catch (std::out_of_range& e) {
63572       {
63573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63574       };
63575     } catch (std::exception& e) {
63576       {
63577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63578       };
63579     } catch (Dali::DaliException e) {
63580       {
63581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63582       };
63583     } catch (...) {
63584       {
63585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63586       };
63587     }
63588   }
63589
63590   jresult = result;
63591   return jresult;
63592 }
63593
63594
63595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63597
63598   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63599   {
63600     try {
63601       (arg1)->ClearKeyInputFocus();
63602     } catch (std::out_of_range& e) {
63603       {
63604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63605       };
63606     } catch (std::exception& e) {
63607       {
63608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63609       };
63610     } catch (Dali::DaliException e) {
63611       {
63612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63613       };
63614     } catch (...) {
63615       {
63616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63617       };
63618     }
63619   }
63620
63621 }
63622
63623
63624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63625   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63626   bool arg2 ;
63627
63628   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63629   arg2 = jarg2 ? true : false;
63630   {
63631     try {
63632       (arg1)->SetAsKeyboardFocusGroup(arg2);
63633     } catch (std::out_of_range& e) {
63634       {
63635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63636       };
63637     } catch (std::exception& e) {
63638       {
63639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63640       };
63641     } catch (Dali::DaliException e) {
63642       {
63643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63644       };
63645     } catch (...) {
63646       {
63647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63648       };
63649     }
63650   }
63651
63652 }
63653
63654
63655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63656   unsigned int jresult ;
63657   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63658   bool result;
63659
63660   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63661   {
63662     try {
63663       result = (bool)(arg1)->IsKeyboardFocusGroup();
63664     } catch (std::out_of_range& e) {
63665       {
63666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63667       };
63668     } catch (std::exception& e) {
63669       {
63670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63671       };
63672     } catch (Dali::DaliException e) {
63673       {
63674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63675       };
63676     } catch (...) {
63677       {
63678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63679       };
63680     }
63681   }
63682
63683   jresult = result;
63684   return jresult;
63685 }
63686
63687
63688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63689   void * jresult ;
63690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63691   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63692
63693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63694   {
63695     try {
63696       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63697     } catch (std::out_of_range& e) {
63698       {
63699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63700       };
63701     } catch (std::exception& e) {
63702       {
63703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63704       };
63705     } catch (Dali::DaliException e) {
63706       {
63707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63708       };
63709     } catch (...) {
63710       {
63711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63712       };
63713     }
63714   }
63715
63716   jresult = (void *)result;
63717   return jresult;
63718 }
63719
63720
63721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63722   void * jresult ;
63723   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63724   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63725
63726   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63727   {
63728     try {
63729       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63730     } catch (std::out_of_range& e) {
63731       {
63732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63733       };
63734     } catch (std::exception& e) {
63735       {
63736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63737       };
63738     } catch (Dali::DaliException e) {
63739       {
63740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63741       };
63742     } catch (...) {
63743       {
63744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63745       };
63746     }
63747   }
63748
63749   jresult = (void *)result;
63750   return jresult;
63751 }
63752
63753
63754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63755   void * jresult ;
63756   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63757   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63758
63759   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63760   {
63761     try {
63762       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63763     } catch (std::out_of_range& e) {
63764       {
63765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63766       };
63767     } catch (std::exception& e) {
63768       {
63769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63770       };
63771     } catch (Dali::DaliException e) {
63772       {
63773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63774       };
63775     } catch (...) {
63776       {
63777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63778       };
63779     }
63780   }
63781
63782   jresult = (void *)result;
63783   return jresult;
63784 }
63785
63786
63787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63788   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63789   int arg2 ;
63790   SwigDirector_ViewImpl *darg = 0;
63791
63792   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63793   arg2 = (int)jarg2;
63794   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63795   if(!darg) {
63796     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63797     return;
63798   }
63799   {
63800     try {
63801       if(darg) {
63802         (darg)->OnStageConnection(arg2);
63803       }
63804     } catch (std::out_of_range& e) {
63805       {
63806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63807       };
63808     } catch (std::exception& e) {
63809       {
63810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63811       };
63812     } catch (Dali::DaliException e) {
63813       {
63814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63815       };
63816     } catch (...) {
63817       {
63818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63819       };
63820     }
63821   }
63822
63823 }
63824
63825
63826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63828   int arg2 ;
63829   SwigDirector_ViewImpl *darg = 0;
63830
63831   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63832   arg2 = (int)jarg2;
63833   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63834   if(!darg) {
63835     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63836     return;
63837   }
63838   {
63839     try {
63840       if(darg) {
63841         (darg)->OnStageConnectionSwigPublic(arg2);
63842       }
63843     } catch (std::out_of_range& e) {
63844       {
63845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63846       };
63847     } catch (std::exception& e) {
63848       {
63849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63850       };
63851     } catch (Dali::DaliException e) {
63852       {
63853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63854       };
63855     } catch (...) {
63856       {
63857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63858       };
63859     }
63860   }
63861
63862 }
63863
63864
63865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63866   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63867   SwigDirector_ViewImpl *darg = 0;
63868
63869   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63870   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63871   if(!darg) {
63872     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63873     return;
63874   }
63875   {
63876     try {
63877       if(darg) {
63878         (darg)->OnStageDisconnection();
63879       }
63880     } catch (std::out_of_range& e) {
63881       {
63882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63883       };
63884     } catch (std::exception& e) {
63885       {
63886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63887       };
63888     } catch (Dali::DaliException e) {
63889       {
63890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63891       };
63892     } catch (...) {
63893       {
63894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63895       };
63896     }
63897   }
63898
63899 }
63900
63901
63902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63904   SwigDirector_ViewImpl *darg = 0;
63905
63906   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63907   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63908   if(!darg) {
63909     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63910     return;
63911   }
63912   {
63913     try {
63914       if(darg) {
63915         (darg)->OnStageDisconnectionSwigPublic();
63916       }
63917     } catch (std::out_of_range& e) {
63918       {
63919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63920       };
63921     } catch (std::exception& e) {
63922       {
63923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63924       };
63925     } catch (Dali::DaliException e) {
63926       {
63927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63928       };
63929     } catch (...) {
63930       {
63931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63932       };
63933     }
63934   }
63935
63936 }
63937
63938
63939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63941   Dali::Actor *arg2 = 0 ;
63942   SwigDirector_ViewImpl *darg = 0;
63943
63944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63945   arg2 = (Dali::Actor *)jarg2;
63946   if (!arg2) {
63947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63948     return ;
63949   }
63950   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63951   if(!darg) {
63952     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63953     return;
63954   }
63955   {
63956     try {
63957       if(darg) {
63958         (darg)->OnChildAdd(*arg2);
63959       }
63960     } catch (std::out_of_range& e) {
63961       {
63962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63963       };
63964     } catch (std::exception& e) {
63965       {
63966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63967       };
63968     } catch (Dali::DaliException e) {
63969       {
63970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63971       };
63972     } catch (...) {
63973       {
63974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63975       };
63976     }
63977   }
63978
63979 }
63980
63981
63982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63984   Dali::Actor *arg2 = 0 ;
63985   SwigDirector_ViewImpl *darg = 0;
63986
63987   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63988   arg2 = (Dali::Actor *)jarg2;
63989   if (!arg2) {
63990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63991     return ;
63992   }
63993   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63994   if(!darg) {
63995     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63996     return;
63997   }
63998   {
63999     try {
64000       if(darg) {
64001           (darg)->OnChildAddSwigPublic(*arg2);
64002       }
64003     } catch (std::out_of_range& e) {
64004       {
64005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64006       };
64007     } catch (std::exception& e) {
64008       {
64009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64010       };
64011     } catch (Dali::DaliException e) {
64012       {
64013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64014       };
64015     } catch (...) {
64016       {
64017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64018       };
64019     }
64020   }
64021
64022 }
64023
64024
64025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64027   Dali::Actor *arg2 = 0 ;
64028   SwigDirector_ViewImpl *darg = 0;
64029
64030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64031   arg2 = (Dali::Actor *)jarg2;
64032   if (!arg2) {
64033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64034     return ;
64035   }
64036   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64037   if(!darg) {
64038     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64039     return;
64040   }
64041   {
64042     try {
64043       if(darg) {
64044         (darg)->OnChildRemove(*arg2);
64045       }
64046     } catch (std::out_of_range& e) {
64047       {
64048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64049       };
64050     } catch (std::exception& e) {
64051       {
64052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64053       };
64054     } catch (Dali::DaliException e) {
64055       {
64056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64057       };
64058     } catch (...) {
64059       {
64060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64061       };
64062     }
64063   }
64064
64065 }
64066
64067
64068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64070   Dali::Actor *arg2 = 0 ;
64071   SwigDirector_ViewImpl *darg = 0;
64072
64073   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64074   arg2 = (Dali::Actor *)jarg2;
64075   if (!arg2) {
64076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64077     return ;
64078   }
64079   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64080   if(!darg) {
64081     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64082     return;
64083   }
64084   {
64085     try {
64086       if(darg) {
64087         (darg)->OnChildRemoveSwigPublic(*arg2);
64088       }
64089     } catch (std::out_of_range& e) {
64090       {
64091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64092       };
64093     } catch (std::exception& e) {
64094       {
64095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64096       };
64097     } catch (Dali::DaliException e) {
64098       {
64099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64100       };
64101     } catch (...) {
64102       {
64103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64104       };
64105     }
64106   }
64107
64108 }
64109
64110
64111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64113   Dali::Property::Index arg2 ;
64114   Dali::Property::Value arg3 ;
64115   Dali::Property::Value *argp3 ;
64116   SwigDirector_ViewImpl *darg = 0;
64117
64118   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64119   arg2 = (Dali::Property::Index)jarg2;
64120   argp3 = (Dali::Property::Value *)jarg3;
64121   if (!argp3) {
64122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64123     return ;
64124   }
64125   arg3 = *argp3;
64126   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64127   if (!darg) {
64128     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64129     return;
64130   }
64131   {
64132     try {
64133       (darg)->OnPropertySet(arg2,arg3);
64134     } catch (std::out_of_range& e) {
64135       {
64136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64137       };
64138     } catch (std::exception& e) {
64139       {
64140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64141       };
64142     } catch (Dali::DaliException e) {
64143       {
64144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64145       };
64146     } catch (...) {
64147       {
64148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64149       };
64150     }
64151   }
64152
64153 }
64154
64155
64156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64157   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64158   Dali::Property::Index arg2 ;
64159   Dali::Property::Value arg3 ;
64160   Dali::Property::Value *argp3 ;
64161   SwigDirector_ViewImpl *darg = 0;
64162
64163   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64164   arg2 = (Dali::Property::Index)jarg2;
64165   argp3 = (Dali::Property::Value *)jarg3;
64166   if (!argp3) {
64167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64168     return ;
64169   }
64170   arg3 = *argp3;
64171   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64172   if (!darg) {
64173     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64174     return;
64175   }
64176   {
64177     try {
64178       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64179     } catch (std::out_of_range& e) {
64180       {
64181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64182       };
64183     } catch (std::exception& e) {
64184       {
64185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64186       };
64187     } catch (Dali::DaliException e) {
64188       {
64189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64190       };
64191     } catch (...) {
64192       {
64193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64194       };
64195     }
64196   }
64197
64198 }
64199
64200
64201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64203   Dali::Vector3 *arg2 = 0 ;
64204   SwigDirector_ViewImpl *darg = 0;
64205
64206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64207   arg2 = (Dali::Vector3 *)jarg2;
64208   if (!arg2) {
64209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64210     return ;
64211   }
64212   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64213   if (!darg) {
64214     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64215     return;
64216   }
64217   {
64218     try {
64219       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64220     } catch (std::out_of_range& e) {
64221       {
64222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64223       };
64224     } catch (std::exception& e) {
64225       {
64226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64227       };
64228     } catch (Dali::DaliException e) {
64229       {
64230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64231       };
64232     } catch (...) {
64233       {
64234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64235       };
64236     }
64237   }
64238
64239 }
64240
64241
64242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64243   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64244   Dali::Vector3 *arg2 = 0 ;
64245   SwigDirector_ViewImpl *darg = 0;
64246
64247   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64248   arg2 = (Dali::Vector3 *)jarg2;
64249   if (!arg2) {
64250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64251     return ;
64252   }
64253   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64254   if (!darg) {
64255     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64256     return;
64257   }
64258   {
64259     try {
64260       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64261     } catch (std::out_of_range& e) {
64262       {
64263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64264       };
64265     } catch (std::exception& e) {
64266       {
64267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64268       };
64269     } catch (Dali::DaliException e) {
64270       {
64271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64272       };
64273     } catch (...) {
64274       {
64275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64276       };
64277     }
64278   }
64279
64280 }
64281
64282
64283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64285   Dali::Animation *arg2 = 0 ;
64286   Dali::Vector3 *arg3 = 0 ;
64287   SwigDirector_ViewImpl *darg = 0;
64288
64289   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64290   arg2 = (Dali::Animation *)jarg2;
64291   if (!arg2) {
64292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64293     return ;
64294   }
64295   arg3 = (Dali::Vector3 *)jarg3;
64296   if (!arg3) {
64297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64298     return ;
64299   }
64300   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64301   if (!darg) {
64302     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64303     return;
64304   }
64305   {
64306     try {
64307       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64308     } catch (std::out_of_range& e) {
64309       {
64310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64311       };
64312     } catch (std::exception& e) {
64313       {
64314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64315       };
64316     } catch (Dali::DaliException e) {
64317       {
64318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64319       };
64320     } catch (...) {
64321       {
64322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64323       };
64324     }
64325   }
64326
64327 }
64328
64329
64330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64332   Dali::Animation *arg2 = 0 ;
64333   Dali::Vector3 *arg3 = 0 ;
64334   SwigDirector_ViewImpl *darg = 0;
64335
64336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64337   arg2 = (Dali::Animation *)jarg2;
64338   if (!arg2) {
64339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64340     return ;
64341   }
64342   arg3 = (Dali::Vector3 *)jarg3;
64343   if (!arg3) {
64344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64345     return ;
64346   }
64347   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64348   if (!darg) {
64349     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64350     return;
64351   }
64352   {
64353     try {
64354       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64355     } catch (std::out_of_range& e) {
64356       {
64357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64358       };
64359     } catch (std::exception& e) {
64360       {
64361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64362       };
64363     } catch (Dali::DaliException e) {
64364       {
64365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64366       };
64367     } catch (...) {
64368       {
64369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64370       };
64371     }
64372   }
64373
64374 }
64375
64376
64377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64378   unsigned int jresult ;
64379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64380   Dali::TouchEvent *arg2 = 0 ;
64381   SwigDirector_ViewImpl *darg = 0;
64382   bool result;
64383
64384   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64385   arg2 = (Dali::TouchEvent *)jarg2;
64386   if (!arg2) {
64387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64388     return 0;
64389   }
64390   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64391   if (!darg) {
64392     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64393     return 0;
64394   }
64395   {
64396     try {
64397       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64398     } catch (std::out_of_range& e) {
64399       {
64400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64401       };
64402     } catch (std::exception& e) {
64403       {
64404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64405       };
64406     } catch (Dali::DaliException e) {
64407       {
64408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64409       };
64410     } catch (...) {
64411       {
64412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64413       };
64414     }
64415   }
64416
64417   jresult = result;
64418   return jresult;
64419 }
64420
64421
64422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64423   unsigned int jresult ;
64424   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64425   Dali::TouchEvent *arg2 = 0 ;
64426   SwigDirector_ViewImpl *darg = 0;
64427   bool result;
64428
64429   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64430   arg2 = (Dali::TouchEvent *)jarg2;
64431   if (!arg2) {
64432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64433     return 0;
64434   }
64435   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64436   if (!darg) {
64437     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64438     return 0;
64439   }
64440   {
64441     try {
64442       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64443     } catch (std::out_of_range& e) {
64444       {
64445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64446       };
64447     } catch (std::exception& e) {
64448       {
64449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64450       };
64451     } catch (Dali::DaliException e) {
64452       {
64453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64454       };
64455     } catch (...) {
64456       {
64457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64458       };
64459     }
64460   }
64461
64462   jresult = result;
64463   return jresult;
64464 }
64465
64466
64467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64468   unsigned int jresult ;
64469   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64470   Dali::HoverEvent *arg2 = 0 ;
64471   SwigDirector_ViewImpl *darg = 0;
64472   bool result;
64473
64474   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64475   arg2 = (Dali::HoverEvent *)jarg2;
64476   if (!arg2) {
64477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64478     return 0;
64479   }
64480   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64481   if (!darg) {
64482     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64483     return 0;
64484   }
64485   {
64486     try {
64487       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64488     } catch (std::out_of_range& e) {
64489       {
64490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64491       };
64492     } catch (std::exception& e) {
64493       {
64494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64495       };
64496     } catch (Dali::DaliException e) {
64497       {
64498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64499       };
64500     } catch (...) {
64501       {
64502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64503       };
64504     }
64505   }
64506
64507   jresult = result;
64508   return jresult;
64509 }
64510
64511
64512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64513   unsigned int jresult ;
64514   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64515   Dali::HoverEvent *arg2 = 0 ;
64516   SwigDirector_ViewImpl *darg = 0;
64517   bool result;
64518
64519   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64520   arg2 = (Dali::HoverEvent *)jarg2;
64521   if (!arg2) {
64522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64523     return 0;
64524   }
64525   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64526   if (!darg) {
64527     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64528     return 0;
64529   }
64530   {
64531     try {
64532       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64533     } catch (std::out_of_range& e) {
64534       {
64535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64536       };
64537     } catch (std::exception& e) {
64538       {
64539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64540       };
64541     } catch (Dali::DaliException e) {
64542       {
64543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64544       };
64545     } catch (...) {
64546       {
64547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64548       };
64549     }
64550   }
64551
64552   jresult = result;
64553   return jresult;
64554 }
64555
64556
64557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64558   unsigned int jresult ;
64559   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64560   Dali::KeyEvent *arg2 = 0 ;
64561   SwigDirector_ViewImpl *darg = 0;
64562   bool result;
64563
64564   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64565   arg2 = (Dali::KeyEvent *)jarg2;
64566   if (!arg2) {
64567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64568     return 0;
64569   }
64570   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64571   if (!darg) {
64572     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64573     return 0;
64574   }
64575   {
64576     try {
64577       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64578     } catch (std::out_of_range& e) {
64579       {
64580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64581       };
64582     } catch (std::exception& e) {
64583       {
64584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64585       };
64586     } catch (Dali::DaliException e) {
64587       {
64588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64589       };
64590     } catch (...) {
64591       {
64592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64593       };
64594     }
64595   }
64596
64597   jresult = result;
64598   return jresult;
64599 }
64600
64601
64602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64603   unsigned int jresult ;
64604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64605   Dali::KeyEvent *arg2 = 0 ;
64606   SwigDirector_ViewImpl *darg = 0;
64607   bool result;
64608
64609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64610   arg2 = (Dali::KeyEvent *)jarg2;
64611   if (!arg2) {
64612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64613     return 0;
64614   }
64615   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64616   if (!darg) {
64617     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64618     return 0;
64619   }
64620   {
64621     try {
64622       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64623     } catch (std::out_of_range& e) {
64624       {
64625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64626       };
64627     } catch (std::exception& e) {
64628       {
64629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64630       };
64631     } catch (Dali::DaliException e) {
64632       {
64633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64634       };
64635     } catch (...) {
64636       {
64637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64638       };
64639     }
64640   }
64641
64642   jresult = result;
64643   return jresult;
64644 }
64645
64646
64647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64648   unsigned int jresult ;
64649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64650   Dali::WheelEvent *arg2 = 0 ;
64651   SwigDirector_ViewImpl *darg = 0;
64652   bool result;
64653
64654   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64655   arg2 = (Dali::WheelEvent *)jarg2;
64656   if (!arg2) {
64657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64658     return 0;
64659   }
64660   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64661   if (!darg) {
64662     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64663     return 0;
64664   }
64665   {
64666     try {
64667       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64668     } catch (std::out_of_range& e) {
64669       {
64670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64671       };
64672     } catch (std::exception& e) {
64673       {
64674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64675       };
64676     } catch (Dali::DaliException e) {
64677       {
64678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64679       };
64680     } catch (...) {
64681       {
64682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64683       };
64684     }
64685   }
64686
64687   jresult = result;
64688   return jresult;
64689 }
64690
64691
64692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64693   unsigned int jresult ;
64694   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64695   Dali::WheelEvent *arg2 = 0 ;
64696   SwigDirector_ViewImpl *darg = 0;
64697   bool result;
64698
64699   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64700   arg2 = (Dali::WheelEvent *)jarg2;
64701   if (!arg2) {
64702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64703     return 0;
64704   }
64705   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64706   if (!darg) {
64707     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64708     return 0;
64709   }
64710   {
64711     try {
64712       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64713     } catch (std::out_of_range& e) {
64714       {
64715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64716       };
64717     } catch (std::exception& e) {
64718       {
64719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64720       };
64721     } catch (Dali::DaliException e) {
64722       {
64723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64724       };
64725     } catch (...) {
64726       {
64727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64728       };
64729     }
64730   }
64731
64732   jresult = result;
64733   return jresult;
64734 }
64735
64736
64737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64739   Dali::Vector2 *arg2 = 0 ;
64740   Dali::RelayoutContainer *arg3 = 0 ;
64741   SwigDirector_ViewImpl *darg = 0;
64742
64743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64744   arg2 = (Dali::Vector2 *)jarg2;
64745   if (!arg2) {
64746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64747     return ;
64748   }
64749   arg3 = (Dali::RelayoutContainer *)jarg3;
64750   if (!arg3) {
64751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64752     return ;
64753   }
64754   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64755   if (!darg) {
64756     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64757     return;
64758   }
64759   {
64760     try {
64761       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64762     } catch (std::out_of_range& e) {
64763       {
64764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64765       };
64766     } catch (std::exception& e) {
64767       {
64768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64769       };
64770     } catch (Dali::DaliException e) {
64771       {
64772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64773       };
64774     } catch (...) {
64775       {
64776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64777       };
64778     }
64779   }
64780
64781 }
64782
64783
64784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64785   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64786   Dali::Vector2 *arg2 = 0 ;
64787   Dali::RelayoutContainer *arg3 = 0 ;
64788   SwigDirector_ViewImpl *darg = 0;
64789
64790   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64791   arg2 = (Dali::Vector2 *)jarg2;
64792   if (!arg2) {
64793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64794     return ;
64795   }
64796   arg3 = (Dali::RelayoutContainer *)jarg3;
64797   if (!arg3) {
64798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64799     return ;
64800   }
64801   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64802   if (!darg) {
64803     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64804     return;
64805   }
64806   {
64807     try {
64808       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64809     } catch (std::out_of_range& e) {
64810       {
64811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64812       };
64813     } catch (std::exception& e) {
64814       {
64815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64816       };
64817     } catch (Dali::DaliException e) {
64818       {
64819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64820       };
64821     } catch (...) {
64822       {
64823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64824       };
64825     }
64826   }
64827
64828 }
64829
64830
64831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64833   Dali::ResizePolicy::Type arg2 ;
64834   Dali::Dimension::Type arg3 ;
64835   SwigDirector_ViewImpl *darg = 0;
64836
64837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64838   arg2 = (Dali::ResizePolicy::Type)jarg2;
64839   arg3 = (Dali::Dimension::Type)jarg3;
64840   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64841   if (!darg) {
64842     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64843     return;
64844   }
64845   {
64846     try {
64847       (darg)->OnSetResizePolicy(arg2,arg3);
64848     } catch (std::out_of_range& e) {
64849       {
64850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64851       };
64852     } catch (std::exception& e) {
64853       {
64854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64855       };
64856     } catch (Dali::DaliException e) {
64857       {
64858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64859       };
64860     } catch (...) {
64861       {
64862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64863       };
64864     }
64865   }
64866
64867 }
64868
64869
64870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64872   Dali::ResizePolicy::Type arg2 ;
64873   Dali::Dimension::Type arg3 ;
64874   SwigDirector_ViewImpl *darg = 0;
64875
64876   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64877   arg2 = (Dali::ResizePolicy::Type)jarg2;
64878   arg3 = (Dali::Dimension::Type)jarg3;
64879   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64880   if (!darg) {
64881     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64882     return;
64883   }
64884   {
64885     try {
64886       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64887     } catch (std::out_of_range& e) {
64888       {
64889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64890       };
64891     } catch (std::exception& e) {
64892       {
64893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64894       };
64895     } catch (Dali::DaliException e) {
64896       {
64897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64898       };
64899     } catch (...) {
64900       {
64901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64902       };
64903     }
64904   }
64905
64906 }
64907
64908
64909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64910   void * jresult ;
64911   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64912   SwigDirector_ViewImpl *darg = 0;
64913   Dali::Vector3 result;
64914
64915   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64916   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64917   if (!darg) {
64918     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64919     return 0;
64920   }
64921   {
64922     try {
64923       result = (darg)->GetNaturalSize();
64924     } catch (std::out_of_range& e) {
64925       {
64926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64927       };
64928     } catch (std::exception& e) {
64929       {
64930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64931       };
64932     } catch (Dali::DaliException e) {
64933       {
64934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64935       };
64936     } catch (...) {
64937       {
64938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64939       };
64940     }
64941   }
64942
64943   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64944   return jresult;
64945 }
64946
64947
64948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64949   void * jresult ;
64950   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64951   SwigDirector_ViewImpl *darg = 0;
64952   Dali::Vector3 result;
64953
64954   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64955   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64956   if (!darg) {
64957     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64958     return 0;
64959   }
64960   {
64961     try {
64962       result = (darg)->GetNaturalSizeSwigPublic();
64963     } catch (std::out_of_range& e) {
64964       {
64965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64966       };
64967     } catch (std::exception& e) {
64968       {
64969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64970       };
64971     } catch (Dali::DaliException e) {
64972       {
64973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64974       };
64975     } catch (...) {
64976       {
64977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64978       };
64979     }
64980   }
64981
64982   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64983   return jresult;
64984 }
64985
64986
64987 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64988   float jresult ;
64989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64990   Dali::Actor *arg2 = 0 ;
64991   Dali::Dimension::Type arg3 ;
64992   SwigDirector_ViewImpl *darg = 0;
64993   float result;
64994
64995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64996   arg2 = (Dali::Actor *)jarg2;
64997   if (!arg2) {
64998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64999     return 0;
65000   }
65001   arg3 = (Dali::Dimension::Type)jarg3;
65002   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65003   if (!darg) {
65004     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65005     return 0;
65006   }
65007   {
65008     try {
65009       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65010     } catch (std::out_of_range& e) {
65011       {
65012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65013       };
65014     } catch (std::exception& e) {
65015       {
65016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65017       };
65018     } catch (Dali::DaliException e) {
65019       {
65020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65021       };
65022     } catch (...) {
65023       {
65024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65025       };
65026     }
65027   }
65028
65029   jresult = result;
65030   return jresult;
65031 }
65032
65033
65034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65035   float jresult ;
65036   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65037   Dali::Actor *arg2 = 0 ;
65038   Dali::Dimension::Type arg3 ;
65039   SwigDirector_ViewImpl *darg = 0;
65040   float result;
65041
65042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65043   arg2 = (Dali::Actor *)jarg2;
65044   if (!arg2) {
65045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65046     return 0;
65047   }
65048   arg3 = (Dali::Dimension::Type)jarg3;
65049   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65050   if (!darg) {
65051     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65052     return 0;
65053   }
65054   {
65055     try {
65056       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65057     } catch (std::out_of_range& e) {
65058       {
65059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65060       };
65061     } catch (std::exception& e) {
65062       {
65063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65064       };
65065     } catch (Dali::DaliException e) {
65066       {
65067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65068       };
65069     } catch (...) {
65070       {
65071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65072       };
65073     }
65074   }
65075
65076   jresult = result;
65077   return jresult;
65078 }
65079
65080
65081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65082   float jresult ;
65083   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65084   float arg2 ;
65085   SwigDirector_ViewImpl *darg = 0;
65086   float result;
65087
65088   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65089   arg2 = (float)jarg2;
65090   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65091   if (!darg) {
65092     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65093     return 0;
65094   }
65095   {
65096     try {
65097       result = (float)(darg)->GetHeightForWidth(arg2);
65098     } catch (std::out_of_range& e) {
65099       {
65100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65101       };
65102     } catch (std::exception& e) {
65103       {
65104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65105       };
65106     } catch (Dali::DaliException e) {
65107       {
65108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65109       };
65110     } catch (...) {
65111       {
65112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65113       };
65114     }
65115   }
65116
65117   jresult = result;
65118   return jresult;
65119 }
65120
65121
65122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65123   float jresult ;
65124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65125   float arg2 ;
65126   SwigDirector_ViewImpl *darg = 0;
65127   float result;
65128
65129   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65130   arg2 = (float)jarg2;
65131   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65132   if (!darg) {
65133     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65134     return 0;
65135   }
65136   {
65137     try {
65138       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65139     } catch (std::out_of_range& e) {
65140       {
65141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65142       };
65143     } catch (std::exception& e) {
65144       {
65145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65146       };
65147     } catch (Dali::DaliException e) {
65148       {
65149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65150       };
65151     } catch (...) {
65152       {
65153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65154       };
65155     }
65156   }
65157
65158   jresult = result;
65159   return jresult;
65160 }
65161
65162
65163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65164   float jresult ;
65165   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65166   float arg2 ;
65167   SwigDirector_ViewImpl *darg = 0;
65168   float result;
65169
65170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65171   arg2 = (float)jarg2;
65172   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65173   if (!darg) {
65174     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65175     return 0;
65176   }
65177   {
65178     try {
65179       result = (float)(darg)->GetWidthForHeight(arg2);
65180     } catch (std::out_of_range& e) {
65181       {
65182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65183       };
65184     } catch (std::exception& e) {
65185       {
65186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65187       };
65188     } catch (Dali::DaliException e) {
65189       {
65190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65191       };
65192     } catch (...) {
65193       {
65194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65195       };
65196     }
65197   }
65198
65199   jresult = result;
65200   return jresult;
65201 }
65202
65203
65204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65205   float jresult ;
65206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65207   float arg2 ;
65208   SwigDirector_ViewImpl *darg = 0;
65209   float result;
65210
65211   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65212   arg2 = (float)jarg2;
65213   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65214   if (!darg) {
65215     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65216     return 0;
65217   }
65218   {
65219     try {
65220       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65221     } catch (std::out_of_range& e) {
65222       {
65223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65224       };
65225     } catch (std::exception& e) {
65226       {
65227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65228       };
65229     } catch (Dali::DaliException e) {
65230       {
65231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65232       };
65233     } catch (...) {
65234       {
65235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65236       };
65237     }
65238   }
65239
65240   jresult = result;
65241   return jresult;
65242 }
65243
65244
65245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65246   unsigned int jresult ;
65247   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65248   Dali::Dimension::Type arg2 ;
65249   SwigDirector_ViewImpl *darg = 0;
65250   bool result;
65251
65252   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65253   arg2 = (Dali::Dimension::Type)jarg2;
65254   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65255   if (!darg) {
65256     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65257     return 0;
65258   }
65259   {
65260     try {
65261       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65262     } catch (std::out_of_range& e) {
65263       {
65264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65265       };
65266     } catch (std::exception& e) {
65267       {
65268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65269       };
65270     } catch (Dali::DaliException e) {
65271       {
65272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65273       };
65274     } catch (...) {
65275       {
65276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65277       };
65278     }
65279   }
65280
65281   jresult = result;
65282   return jresult;
65283 }
65284
65285
65286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65287   unsigned int jresult ;
65288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65289   Dali::Dimension::Type arg2 ;
65290   SwigDirector_ViewImpl *darg = 0;
65291   bool result;
65292
65293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65294   arg2 = (Dali::Dimension::Type)jarg2;
65295   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65296   if (!darg) {
65297     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65298     return 0;
65299   }
65300   {
65301     try {
65302       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65303     } catch (std::out_of_range& e) {
65304       {
65305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65306       };
65307     } catch (std::exception& e) {
65308       {
65309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65310       };
65311     } catch (Dali::DaliException e) {
65312       {
65313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65314       };
65315     } catch (...) {
65316       {
65317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65318       };
65319     }
65320   }
65321
65322   jresult = result;
65323   return jresult;
65324 }
65325
65326
65327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65328   unsigned int jresult ;
65329   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65330   SwigDirector_ViewImpl *darg = 0;
65331   bool result;
65332
65333   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65334   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65335   if (!darg) {
65336     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65337     return 0;
65338   }
65339   {
65340     try {
65341       result = (bool)(darg)->RelayoutDependentOnChildren();
65342     } catch (std::out_of_range& e) {
65343       {
65344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65345       };
65346     } catch (std::exception& e) {
65347       {
65348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65349       };
65350     } catch (Dali::DaliException e) {
65351       {
65352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65353       };
65354     } catch (...) {
65355       {
65356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65357       };
65358     }
65359   }
65360
65361   jresult = result;
65362   return jresult;
65363 }
65364
65365
65366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65367   unsigned int jresult ;
65368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65369   SwigDirector_ViewImpl *darg = 0;
65370   bool result;
65371
65372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65373   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65374   if (!darg) {
65375     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65376     return 0;
65377   }
65378   {
65379     try {
65380       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65381     } catch (std::out_of_range& e) {
65382       {
65383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65384       };
65385     } catch (std::exception& e) {
65386       {
65387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65388       };
65389     } catch (Dali::DaliException e) {
65390       {
65391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65392       };
65393     } catch (...) {
65394       {
65395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65396       };
65397     }
65398   }
65399
65400   jresult = result;
65401   return jresult;
65402 }
65403
65404
65405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65406   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65407   Dali::Dimension::Type arg2 ;
65408   SwigDirector_ViewImpl *darg = 0;
65409
65410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65411   arg2 = (Dali::Dimension::Type)jarg2;
65412   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65413   if (!darg) {
65414     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65415     return;
65416   }
65417   {
65418     try {
65419       (darg)->OnCalculateRelayoutSize(arg2);
65420     } catch (std::out_of_range& e) {
65421       {
65422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65423       };
65424     } catch (std::exception& e) {
65425       {
65426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65427       };
65428     } catch (Dali::DaliException e) {
65429       {
65430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65431       };
65432     } catch (...) {
65433       {
65434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65435       };
65436     }
65437   }
65438
65439 }
65440
65441
65442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65444   Dali::Dimension::Type arg2 ;
65445   SwigDirector_ViewImpl *darg = 0;
65446
65447   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65448   arg2 = (Dali::Dimension::Type)jarg2;
65449   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65450   if (!darg) {
65451     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65452     return;
65453   }
65454   {
65455     try {
65456       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65457     } catch (std::out_of_range& e) {
65458       {
65459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65460       };
65461     } catch (std::exception& e) {
65462       {
65463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65464       };
65465     } catch (Dali::DaliException e) {
65466       {
65467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65468       };
65469     } catch (...) {
65470       {
65471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65472       };
65473     }
65474   }
65475
65476 }
65477
65478
65479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65481   float arg2 ;
65482   Dali::Dimension::Type arg3 ;
65483   SwigDirector_ViewImpl *darg = 0;
65484
65485   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65486   arg2 = (float)jarg2;
65487   arg3 = (Dali::Dimension::Type)jarg3;
65488   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65489   if (!darg) {
65490     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65491     return;
65492   }
65493   {
65494     try {
65495       (darg)->OnLayoutNegotiated(arg2,arg3);
65496     } catch (std::out_of_range& e) {
65497       {
65498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65499       };
65500     } catch (std::exception& e) {
65501       {
65502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65503       };
65504     } catch (Dali::DaliException e) {
65505       {
65506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65507       };
65508     } catch (...) {
65509       {
65510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65511       };
65512     }
65513   }
65514
65515 }
65516
65517
65518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65519   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65520   float arg2 ;
65521   Dali::Dimension::Type arg3 ;
65522   SwigDirector_ViewImpl *darg = 0;
65523
65524   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65525   arg2 = (float)jarg2;
65526   arg3 = (Dali::Dimension::Type)jarg3;
65527   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65528   if (!darg) {
65529     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65530     return;
65531   }
65532   {
65533     try {
65534       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65535     } catch (std::out_of_range& e) {
65536       {
65537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65538       };
65539     } catch (std::exception& e) {
65540       {
65541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65542       };
65543     } catch (Dali::DaliException e) {
65544       {
65545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65546       };
65547     } catch (...) {
65548       {
65549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65550       };
65551     }
65552   }
65553
65554 }
65555
65556
65557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65558   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65559
65560   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65561   {
65562     try {
65563       (arg1)->OnInitialize();
65564     } catch (std::out_of_range& e) {
65565       {
65566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65567       };
65568     } catch (std::exception& e) {
65569       {
65570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65571       };
65572     } catch (Dali::DaliException e) {
65573       {
65574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65575       };
65576     } catch (...) {
65577       {
65578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65579       };
65580     }
65581   }
65582
65583 }
65584
65585
65586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65587   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65588
65589   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65590   {
65591     try {
65592       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65593     } catch (std::out_of_range& e) {
65594       {
65595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65596       };
65597     } catch (std::exception& e) {
65598       {
65599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65600       };
65601     } catch (Dali::DaliException e) {
65602       {
65603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65604       };
65605     } catch (...) {
65606       {
65607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65608       };
65609     }
65610   }
65611
65612 }
65613
65614
65615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65617   Dali::Actor *arg2 = 0 ;
65618
65619   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65620   arg2 = (Dali::Actor *)jarg2;
65621   if (!arg2) {
65622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65623     return ;
65624   }
65625   {
65626     try {
65627       (arg1)->OnControlChildAdd(*arg2);
65628     } catch (std::out_of_range& e) {
65629       {
65630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65631       };
65632     } catch (std::exception& e) {
65633       {
65634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65635       };
65636     } catch (Dali::DaliException e) {
65637       {
65638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65639       };
65640     } catch (...) {
65641       {
65642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65643       };
65644     }
65645   }
65646
65647 }
65648
65649
65650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65651   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65652   Dali::Actor *arg2 = 0 ;
65653
65654   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65655   arg2 = (Dali::Actor *)jarg2;
65656   if (!arg2) {
65657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65658     return ;
65659   }
65660   {
65661     try {
65662       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65663     } catch (std::out_of_range& e) {
65664       {
65665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65666       };
65667     } catch (std::exception& e) {
65668       {
65669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65670       };
65671     } catch (Dali::DaliException e) {
65672       {
65673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65674       };
65675     } catch (...) {
65676       {
65677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65678       };
65679     }
65680   }
65681
65682 }
65683
65684
65685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65687   Dali::Actor *arg2 = 0 ;
65688
65689   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65690   arg2 = (Dali::Actor *)jarg2;
65691   if (!arg2) {
65692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65693     return ;
65694   }
65695   {
65696     try {
65697       (arg1)->OnControlChildRemove(*arg2);
65698     } catch (std::out_of_range& e) {
65699       {
65700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65701       };
65702     } catch (std::exception& e) {
65703       {
65704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65705       };
65706     } catch (Dali::DaliException e) {
65707       {
65708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65709       };
65710     } catch (...) {
65711       {
65712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65713       };
65714     }
65715   }
65716
65717 }
65718
65719
65720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65722   Dali::Actor *arg2 = 0 ;
65723
65724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65725   arg2 = (Dali::Actor *)jarg2;
65726   if (!arg2) {
65727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65728     return ;
65729   }
65730   {
65731     try {
65732       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65733     } catch (std::out_of_range& e) {
65734       {
65735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65736       };
65737     } catch (std::exception& e) {
65738       {
65739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65740       };
65741     } catch (Dali::DaliException e) {
65742       {
65743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65744       };
65745     } catch (...) {
65746       {
65747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65748       };
65749     }
65750   }
65751
65752 }
65753
65754
65755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65756   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65757   Dali::Toolkit::StyleManager arg2 ;
65758   Dali::StyleChange::Type arg3 ;
65759   Dali::Toolkit::StyleManager *argp2 ;
65760
65761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65762   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65763   if (!argp2) {
65764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65765     return ;
65766   }
65767   arg2 = *argp2;
65768   arg3 = (Dali::StyleChange::Type)jarg3;
65769   {
65770     try {
65771       (arg1)->OnStyleChange(arg2,arg3);
65772     } catch (std::out_of_range& e) {
65773       {
65774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65775       };
65776     } catch (std::exception& e) {
65777       {
65778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65779       };
65780     } catch (Dali::DaliException e) {
65781       {
65782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65783       };
65784     } catch (...) {
65785       {
65786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65787       };
65788     }
65789   }
65790
65791 }
65792
65793
65794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65795   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65796   Dali::Toolkit::StyleManager arg2 ;
65797   Dali::StyleChange::Type arg3 ;
65798   Dali::Toolkit::StyleManager *argp2 ;
65799
65800   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65801   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65802   if (!argp2) {
65803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65804     return ;
65805   }
65806   arg2 = *argp2;
65807   arg3 = (Dali::StyleChange::Type)jarg3;
65808   {
65809     try {
65810       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65811     } catch (std::out_of_range& e) {
65812       {
65813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65814       };
65815     } catch (std::exception& e) {
65816       {
65817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65818       };
65819     } catch (Dali::DaliException e) {
65820       {
65821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65822       };
65823     } catch (...) {
65824       {
65825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65826       };
65827     }
65828   }
65829
65830 }
65831
65832
65833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65834   unsigned int jresult ;
65835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65836   bool result;
65837
65838   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65839   {
65840     try {
65841       result = (bool)(arg1)->OnAccessibilityActivated();
65842     } catch (std::out_of_range& e) {
65843       {
65844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65845       };
65846     } catch (std::exception& e) {
65847       {
65848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65849       };
65850     } catch (Dali::DaliException e) {
65851       {
65852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65853       };
65854     } catch (...) {
65855       {
65856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65857       };
65858     }
65859   }
65860
65861   jresult = result;
65862   return jresult;
65863 }
65864
65865
65866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65867   unsigned int jresult ;
65868   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65869   bool result;
65870
65871   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65872   {
65873     try {
65874       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65875     } catch (std::out_of_range& e) {
65876       {
65877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65878       };
65879     } catch (std::exception& e) {
65880       {
65881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65882       };
65883     } catch (Dali::DaliException e) {
65884       {
65885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65886       };
65887     } catch (...) {
65888       {
65889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65890       };
65891     }
65892   }
65893
65894   jresult = result;
65895   return jresult;
65896 }
65897
65898
65899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65900   unsigned int jresult ;
65901   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65902   Dali::PanGesture arg2 ;
65903   Dali::PanGesture *argp2 ;
65904   bool result;
65905
65906   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65907   argp2 = (Dali::PanGesture *)jarg2;
65908   if (!argp2) {
65909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65910     return 0;
65911   }
65912   arg2 = *argp2;
65913   {
65914     try {
65915       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65916     } catch (std::out_of_range& e) {
65917       {
65918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65919       };
65920     } catch (std::exception& e) {
65921       {
65922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65923       };
65924     } catch (Dali::DaliException e) {
65925       {
65926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65927       };
65928     } catch (...) {
65929       {
65930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65931       };
65932     }
65933   }
65934
65935   jresult = result;
65936   return jresult;
65937 }
65938
65939
65940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65941   unsigned int jresult ;
65942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65943   Dali::PanGesture arg2 ;
65944   Dali::PanGesture *argp2 ;
65945   bool result;
65946
65947   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65948   argp2 = (Dali::PanGesture *)jarg2;
65949   if (!argp2) {
65950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65951     return 0;
65952   }
65953   arg2 = *argp2;
65954   {
65955     try {
65956       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65957     } catch (std::out_of_range& e) {
65958       {
65959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65960       };
65961     } catch (std::exception& e) {
65962       {
65963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65964       };
65965     } catch (Dali::DaliException e) {
65966       {
65967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65968       };
65969     } catch (...) {
65970       {
65971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65972       };
65973     }
65974   }
65975
65976   jresult = result;
65977   return jresult;
65978 }
65979
65980
65981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65982   unsigned int jresult ;
65983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65984   Dali::TouchEvent *arg2 = 0 ;
65985   bool result;
65986
65987   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65988   arg2 = (Dali::TouchEvent *)jarg2;
65989   if (!arg2) {
65990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65991     return 0;
65992   }
65993   {
65994     try {
65995       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65996     } catch (std::out_of_range& e) {
65997       {
65998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65999       };
66000     } catch (std::exception& e) {
66001       {
66002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66003       };
66004     } catch (Dali::DaliException e) {
66005       {
66006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66007       };
66008     } catch (...) {
66009       {
66010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66011       };
66012     }
66013   }
66014
66015   jresult = result;
66016   return jresult;
66017 }
66018
66019
66020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66021   unsigned int jresult ;
66022   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66023   Dali::TouchEvent *arg2 = 0 ;
66024   bool result;
66025
66026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66027   arg2 = (Dali::TouchEvent *)jarg2;
66028   if (!arg2) {
66029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66030     return 0;
66031   }
66032   {
66033     try {
66034       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66035     } catch (std::out_of_range& e) {
66036       {
66037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66038       };
66039     } catch (std::exception& e) {
66040       {
66041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66042       };
66043     } catch (Dali::DaliException e) {
66044       {
66045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66046       };
66047     } catch (...) {
66048       {
66049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66050       };
66051     }
66052   }
66053
66054   jresult = result;
66055   return jresult;
66056 }
66057
66058
66059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66060   unsigned int jresult ;
66061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66062   bool arg2 ;
66063   bool result;
66064
66065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66066   arg2 = jarg2 ? true : false;
66067   {
66068     try {
66069       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66070     } catch (std::out_of_range& e) {
66071       {
66072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66073       };
66074     } catch (std::exception& e) {
66075       {
66076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66077       };
66078     } catch (Dali::DaliException e) {
66079       {
66080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66081       };
66082     } catch (...) {
66083       {
66084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66085       };
66086     }
66087   }
66088
66089   jresult = result;
66090   return jresult;
66091 }
66092
66093
66094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66095   unsigned int jresult ;
66096   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66097   bool arg2 ;
66098   bool result;
66099
66100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66101   arg2 = jarg2 ? true : false;
66102   {
66103     try {
66104       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66105     } catch (std::out_of_range& e) {
66106       {
66107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66108       };
66109     } catch (std::exception& e) {
66110       {
66111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66112       };
66113     } catch (Dali::DaliException e) {
66114       {
66115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66116       };
66117     } catch (...) {
66118       {
66119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66120       };
66121     }
66122   }
66123
66124   jresult = result;
66125   return jresult;
66126 }
66127
66128
66129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66130   unsigned int jresult ;
66131   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66132   bool result;
66133
66134   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66135   {
66136     try {
66137       result = (bool)(arg1)->OnAccessibilityZoom();
66138     } catch (std::out_of_range& e) {
66139       {
66140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66141       };
66142     } catch (std::exception& e) {
66143       {
66144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66145       };
66146     } catch (Dali::DaliException e) {
66147       {
66148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66149       };
66150     } catch (...) {
66151       {
66152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66153       };
66154     }
66155   }
66156
66157   jresult = result;
66158   return jresult;
66159 }
66160
66161
66162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66163   unsigned int jresult ;
66164   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66165   bool result;
66166
66167   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66168   {
66169     try {
66170       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66171     } catch (std::out_of_range& e) {
66172       {
66173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66174       };
66175     } catch (std::exception& e) {
66176       {
66177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66178       };
66179     } catch (Dali::DaliException e) {
66180       {
66181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66182       };
66183     } catch (...) {
66184       {
66185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66186       };
66187     }
66188   }
66189
66190   jresult = result;
66191   return jresult;
66192 }
66193
66194
66195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66196   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66197
66198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66199   {
66200     try {
66201       (arg1)->OnKeyInputFocusGained();
66202     } catch (std::out_of_range& e) {
66203       {
66204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66205       };
66206     } catch (std::exception& e) {
66207       {
66208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66209       };
66210     } catch (Dali::DaliException e) {
66211       {
66212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66213       };
66214     } catch (...) {
66215       {
66216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66217       };
66218     }
66219   }
66220
66221 }
66222
66223
66224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66225   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66226
66227   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66228   {
66229     try {
66230       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66231     } catch (std::out_of_range& e) {
66232       {
66233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66234       };
66235     } catch (std::exception& e) {
66236       {
66237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66238       };
66239     } catch (Dali::DaliException e) {
66240       {
66241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66242       };
66243     } catch (...) {
66244       {
66245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66246       };
66247     }
66248   }
66249
66250 }
66251
66252
66253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66255
66256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66257   {
66258     try {
66259       (arg1)->OnKeyInputFocusLost();
66260     } catch (std::out_of_range& e) {
66261       {
66262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66263       };
66264     } catch (std::exception& e) {
66265       {
66266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66267       };
66268     } catch (Dali::DaliException e) {
66269       {
66270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66271       };
66272     } catch (...) {
66273       {
66274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66275       };
66276     }
66277   }
66278
66279 }
66280
66281
66282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66284
66285   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66286   {
66287     try {
66288       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66289     } catch (std::out_of_range& e) {
66290       {
66291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66292       };
66293     } catch (std::exception& e) {
66294       {
66295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66296       };
66297     } catch (Dali::DaliException e) {
66298       {
66299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66300       };
66301     } catch (...) {
66302       {
66303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66304       };
66305     }
66306   }
66307
66308 }
66309
66310
66311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66312   void * jresult ;
66313   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66314   Dali::Actor arg2 ;
66315   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66316   bool arg4 ;
66317   Dali::Actor *argp2 ;
66318   Dali::Actor result;
66319
66320   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66321   argp2 = (Dali::Actor *)jarg2;
66322   if (!argp2) {
66323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66324     return 0;
66325   }
66326   arg2 = *argp2;
66327   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66328   arg4 = jarg4 ? true : false;
66329   {
66330     try {
66331       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66332     } catch (std::out_of_range& e) {
66333       {
66334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66335       };
66336     } catch (std::exception& e) {
66337       {
66338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66339       };
66340     } catch (Dali::DaliException e) {
66341       {
66342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66343       };
66344     } catch (...) {
66345       {
66346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66347       };
66348     }
66349   }
66350
66351   jresult = new Dali::Actor((const Dali::Actor &)result);
66352   return jresult;
66353 }
66354
66355
66356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66357   void * jresult ;
66358   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66359   Dali::Actor arg2 ;
66360   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66361   bool arg4 ;
66362   Dali::Actor *argp2 ;
66363   Dali::Actor result;
66364
66365   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66366   argp2 = (Dali::Actor *)jarg2;
66367   if (!argp2) {
66368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66369     return 0;
66370   }
66371   arg2 = *argp2;
66372   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66373   arg4 = jarg4 ? true : false;
66374   {
66375     try {
66376       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66377     } catch (std::out_of_range& e) {
66378       {
66379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66380       };
66381     } catch (std::exception& e) {
66382       {
66383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66384       };
66385     } catch (Dali::DaliException e) {
66386       {
66387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66388       };
66389     } catch (...) {
66390       {
66391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66392       };
66393     }
66394   }
66395
66396   jresult = new Dali::Actor((const Dali::Actor &)result);
66397   return jresult;
66398 }
66399
66400
66401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66402   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66403   Dali::Actor arg2 ;
66404   Dali::Actor *argp2 ;
66405
66406   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66407   argp2 = (Dali::Actor *)jarg2;
66408   if (!argp2) {
66409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66410     return ;
66411   }
66412   arg2 = *argp2;
66413   {
66414     try {
66415       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66416     } catch (std::out_of_range& e) {
66417       {
66418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66419       };
66420     } catch (std::exception& e) {
66421       {
66422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66423       };
66424     } catch (Dali::DaliException e) {
66425       {
66426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66427       };
66428     } catch (...) {
66429       {
66430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66431       };
66432     }
66433   }
66434
66435 }
66436
66437
66438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66439   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66440   Dali::Actor arg2 ;
66441   Dali::Actor *argp2 ;
66442
66443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66444   argp2 = (Dali::Actor *)jarg2;
66445   if (!argp2) {
66446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66447     return ;
66448   }
66449   arg2 = *argp2;
66450   {
66451     try {
66452       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66453     } catch (std::out_of_range& e) {
66454       {
66455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66456       };
66457     } catch (std::exception& e) {
66458       {
66459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66460       };
66461     } catch (Dali::DaliException e) {
66462       {
66463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66464       };
66465     } catch (...) {
66466       {
66467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66468       };
66469     }
66470   }
66471
66472 }
66473
66474
66475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66476   unsigned int jresult ;
66477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66478   bool result;
66479
66480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66481   {
66482     try {
66483       result = (bool)(arg1)->OnKeyboardEnter();
66484     } catch (std::out_of_range& e) {
66485       {
66486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66487       };
66488     } catch (std::exception& e) {
66489       {
66490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66491       };
66492     } catch (Dali::DaliException e) {
66493       {
66494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66495       };
66496     } catch (...) {
66497       {
66498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66499       };
66500     }
66501   }
66502
66503   jresult = result;
66504   return jresult;
66505 }
66506
66507
66508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66509   unsigned int jresult ;
66510   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66511   bool result;
66512
66513   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66514   {
66515     try {
66516       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66517     } catch (std::out_of_range& e) {
66518       {
66519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66520       };
66521     } catch (std::exception& e) {
66522       {
66523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66524       };
66525     } catch (Dali::DaliException e) {
66526       {
66527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66528       };
66529     } catch (...) {
66530       {
66531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66532       };
66533     }
66534   }
66535
66536   jresult = result;
66537   return jresult;
66538 }
66539
66540
66541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66542   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66543   Dali::PinchGesture *arg2 = 0 ;
66544
66545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66546   arg2 = (Dali::PinchGesture *)jarg2;
66547   if (!arg2) {
66548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66549     return ;
66550   }
66551   {
66552     try {
66553       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66554     } catch (std::out_of_range& e) {
66555       {
66556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66557       };
66558     } catch (std::exception& e) {
66559       {
66560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66561       };
66562     } catch (Dali::DaliException e) {
66563       {
66564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66565       };
66566     } catch (...) {
66567       {
66568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66569       };
66570     }
66571   }
66572
66573 }
66574
66575
66576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66578   Dali::PinchGesture *arg2 = 0 ;
66579
66580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66581   arg2 = (Dali::PinchGesture *)jarg2;
66582   if (!arg2) {
66583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66584     return ;
66585   }
66586   {
66587     try {
66588       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66589     } catch (std::out_of_range& e) {
66590       {
66591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66592       };
66593     } catch (std::exception& e) {
66594       {
66595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66596       };
66597     } catch (Dali::DaliException e) {
66598       {
66599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66600       };
66601     } catch (...) {
66602       {
66603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66604       };
66605     }
66606   }
66607
66608 }
66609
66610
66611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66612   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66613   Dali::PanGesture *arg2 = 0 ;
66614
66615   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66616   arg2 = (Dali::PanGesture *)jarg2;
66617   if (!arg2) {
66618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66619     return ;
66620   }
66621   {
66622     try {
66623       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66624     } catch (std::out_of_range& e) {
66625       {
66626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66627       };
66628     } catch (std::exception& e) {
66629       {
66630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66631       };
66632     } catch (Dali::DaliException e) {
66633       {
66634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66635       };
66636     } catch (...) {
66637       {
66638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66639       };
66640     }
66641   }
66642
66643 }
66644
66645
66646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66648   Dali::PanGesture *arg2 = 0 ;
66649
66650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66651   arg2 = (Dali::PanGesture *)jarg2;
66652   if (!arg2) {
66653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66654     return ;
66655   }
66656   {
66657     try {
66658       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66659     } catch (std::out_of_range& e) {
66660       {
66661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66662       };
66663     } catch (std::exception& e) {
66664       {
66665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66666       };
66667     } catch (Dali::DaliException e) {
66668       {
66669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66670       };
66671     } catch (...) {
66672       {
66673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66674       };
66675     }
66676   }
66677
66678 }
66679
66680
66681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66683   Dali::TapGesture *arg2 = 0 ;
66684
66685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66686   arg2 = (Dali::TapGesture *)jarg2;
66687   if (!arg2) {
66688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66689     return ;
66690   }
66691   {
66692     try {
66693       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66694     } catch (std::out_of_range& e) {
66695       {
66696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66697       };
66698     } catch (std::exception& e) {
66699       {
66700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66701       };
66702     } catch (Dali::DaliException e) {
66703       {
66704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66705       };
66706     } catch (...) {
66707       {
66708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66709       };
66710     }
66711   }
66712
66713 }
66714
66715
66716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66717   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66718   Dali::TapGesture *arg2 = 0 ;
66719
66720   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66721   arg2 = (Dali::TapGesture *)jarg2;
66722   if (!arg2) {
66723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66724     return ;
66725   }
66726   {
66727     try {
66728       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66729     } catch (std::out_of_range& e) {
66730       {
66731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66732       };
66733     } catch (std::exception& e) {
66734       {
66735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66736       };
66737     } catch (Dali::DaliException e) {
66738       {
66739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66740       };
66741     } catch (...) {
66742       {
66743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66744       };
66745     }
66746   }
66747
66748 }
66749
66750
66751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66752   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66753   Dali::LongPressGesture *arg2 = 0 ;
66754
66755   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66756   arg2 = (Dali::LongPressGesture *)jarg2;
66757   if (!arg2) {
66758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66759     return ;
66760   }
66761   {
66762     try {
66763       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66764     } catch (std::out_of_range& e) {
66765       {
66766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66767       };
66768     } catch (std::exception& e) {
66769       {
66770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66771       };
66772     } catch (Dali::DaliException e) {
66773       {
66774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66775       };
66776     } catch (...) {
66777       {
66778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66779       };
66780     }
66781   }
66782
66783 }
66784
66785
66786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66787   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66788   Dali::LongPressGesture *arg2 = 0 ;
66789
66790   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66791   arg2 = (Dali::LongPressGesture *)jarg2;
66792   if (!arg2) {
66793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66794     return ;
66795   }
66796   {
66797     try {
66798       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66799     } catch (std::out_of_range& e) {
66800       {
66801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66802       };
66803     } catch (std::exception& e) {
66804       {
66805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66806       };
66807     } catch (Dali::DaliException e) {
66808       {
66809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66810       };
66811     } catch (...) {
66812       {
66813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66814       };
66815     }
66816   }
66817
66818 }
66819
66820
66821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66822   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66823   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66824   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66825
66826   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66827   arg2 = (Dali::SlotObserver *)jarg2;
66828   arg3 = (Dali::CallbackBase *)jarg3;
66829   {
66830     try {
66831       (arg1)->SignalConnected(arg2,arg3);
66832     } catch (std::out_of_range& e) {
66833       {
66834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66835       };
66836     } catch (std::exception& e) {
66837       {
66838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66839       };
66840     } catch (Dali::DaliException e) {
66841       {
66842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66843       };
66844     } catch (...) {
66845       {
66846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66847       };
66848     }
66849   }
66850
66851 }
66852
66853
66854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66855   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66856   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66857   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66858
66859   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66860   arg2 = (Dali::SlotObserver *)jarg2;
66861   arg3 = (Dali::CallbackBase *)jarg3;
66862   {
66863     try {
66864       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66865     } catch (std::out_of_range& e) {
66866       {
66867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66868       };
66869     } catch (std::exception& e) {
66870       {
66871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66872       };
66873     } catch (Dali::DaliException e) {
66874       {
66875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66876       };
66877     } catch (...) {
66878       {
66879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66880       };
66881     }
66882   }
66883
66884 }
66885
66886
66887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66888   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66889   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66890   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66891
66892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66893   arg2 = (Dali::SlotObserver *)jarg2;
66894   arg3 = (Dali::CallbackBase *)jarg3;
66895   {
66896     try {
66897       (arg1)->SignalDisconnected(arg2,arg3);
66898     } catch (std::out_of_range& e) {
66899       {
66900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66901       };
66902     } catch (std::exception& e) {
66903       {
66904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66905       };
66906     } catch (Dali::DaliException e) {
66907       {
66908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66909       };
66910     } catch (...) {
66911       {
66912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66913       };
66914     }
66915   }
66916
66917 }
66918
66919
66920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66921   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66922   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66923   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66924
66925   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66926   arg2 = (Dali::SlotObserver *)jarg2;
66927   arg3 = (Dali::CallbackBase *)jarg3;
66928   {
66929     try {
66930       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66931     } catch (std::out_of_range& e) {
66932       {
66933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66934       };
66935     } catch (std::exception& e) {
66936       {
66937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66938       };
66939     } catch (Dali::DaliException e) {
66940       {
66941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66942       };
66943     } catch (...) {
66944       {
66945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66946       };
66947     }
66948   }
66949
66950 }
66951
66952
66953 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) {
66954   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66955   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66956   if (director) {
66957     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);
66958   }
66959 }
66960
66961
66962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66963   void * jresult ;
66964   Dali::Toolkit::Control *arg1 = 0 ;
66965   Dali::Toolkit::Internal::Control *result = 0 ;
66966
66967   arg1 = (Dali::Toolkit::Control *)jarg1;
66968   if (!arg1) {
66969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66970     return 0;
66971   }
66972   {
66973     try {
66974       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66975     } catch (std::out_of_range& e) {
66976       {
66977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66978       };
66979     } catch (std::exception& e) {
66980       {
66981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66982       };
66983     } catch (Dali::DaliException e) {
66984       {
66985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66986       };
66987     } catch (...) {
66988       {
66989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66990       };
66991     }
66992   }
66993
66994   jresult = (void *)result;
66995   return jresult;
66996 }
66997
66998
66999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67000   int jresult ;
67001   int result;
67002
67003   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67004   jresult = (int)result;
67005   return jresult;
67006 }
67007
67008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67009   int jresult ;
67010   int result;
67011
67012   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67013   jresult = (int)result;
67014   return jresult;
67015 }
67016
67017
67018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67019   int jresult ;
67020   int result;
67021
67022   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67023   jresult = (int)result;
67024   return jresult;
67025 }
67026
67027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67028   int jresult ;
67029   int result;
67030
67031   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67032   jresult = (int)result;
67033   return jresult;
67034 }
67035
67036
67037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67038   int jresult ;
67039   int result;
67040
67041   result = (int)Dali::Toolkit::Control::Property::PADDING;
67042   jresult = (int)result;
67043   return jresult;
67044 }
67045
67046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
67047   int jresult ;
67048   int result;
67049
67050   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
67051   jresult = (int)result;
67052   return jresult;
67053 }
67054
67055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67056   void * jresult ;
67057   Dali::Toolkit::Control::Property *result = 0 ;
67058
67059   {
67060     try {
67061       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67062     } catch (std::out_of_range& e) {
67063       {
67064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67065       };
67066     } catch (std::exception& e) {
67067       {
67068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67069       };
67070     } catch (Dali::DaliException e) {
67071       {
67072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67073       };
67074     } catch (...) {
67075       {
67076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67077       };
67078     }
67079   }
67080
67081   jresult = (void *)result;
67082   return jresult;
67083 }
67084
67085
67086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67087   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67088
67089   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67090   {
67091     try {
67092       delete arg1;
67093     } catch (std::out_of_range& e) {
67094       {
67095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67096       };
67097     } catch (std::exception& e) {
67098       {
67099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67100       };
67101     } catch (Dali::DaliException e) {
67102       {
67103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67104       };
67105     } catch (...) {
67106       {
67107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67108       };
67109     }
67110   }
67111
67112 }
67113
67114
67115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67116   void * jresult ;
67117   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67118
67119   {
67120     try {
67121       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67122     } catch (std::out_of_range& e) {
67123       {
67124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67125       };
67126     } catch (std::exception& e) {
67127       {
67128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67129       };
67130     } catch (Dali::DaliException e) {
67131       {
67132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67133       };
67134     } catch (...) {
67135       {
67136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67137       };
67138     }
67139   }
67140
67141   jresult = (void *)result;
67142   return jresult;
67143 }
67144
67145
67146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67147   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67148
67149   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67150   {
67151     try {
67152       delete arg1;
67153     } catch (std::out_of_range& e) {
67154       {
67155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67156       };
67157     } catch (std::exception& e) {
67158       {
67159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67160       };
67161     } catch (Dali::DaliException e) {
67162       {
67163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67164       };
67165     } catch (...) {
67166       {
67167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67168       };
67169     }
67170   }
67171
67172 }
67173
67174
67175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67176   void * jresult ;
67177   Dali::Toolkit::Control result;
67178
67179   {
67180     try {
67181       result = Dali::Toolkit::Control::New();
67182     } catch (std::out_of_range& e) {
67183       {
67184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67185       };
67186     } catch (std::exception& e) {
67187       {
67188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67189       };
67190     } catch (Dali::DaliException e) {
67191       {
67192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67193       };
67194     } catch (...) {
67195       {
67196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67197       };
67198     }
67199   }
67200
67201   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67202   return jresult;
67203 }
67204
67205
67206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67207   void * jresult ;
67208   Dali::Toolkit::Control *result = 0 ;
67209
67210   {
67211     try {
67212       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67213     } catch (std::out_of_range& e) {
67214       {
67215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67216       };
67217     } catch (std::exception& e) {
67218       {
67219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67220       };
67221     } catch (Dali::DaliException e) {
67222       {
67223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67224       };
67225     } catch (...) {
67226       {
67227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67228       };
67229     }
67230   }
67231
67232   jresult = (void *)result;
67233   return jresult;
67234 }
67235
67236
67237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67238   void * jresult ;
67239   Dali::Toolkit::Control *arg1 = 0 ;
67240   Dali::Toolkit::Control *result = 0 ;
67241
67242   arg1 = (Dali::Toolkit::Control *)jarg1;
67243   if (!arg1) {
67244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67245     return 0;
67246   }
67247   {
67248     try {
67249       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67250     } catch (std::out_of_range& e) {
67251       {
67252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67253       };
67254     } catch (std::exception& e) {
67255       {
67256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67257       };
67258     } catch (Dali::DaliException e) {
67259       {
67260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67261       };
67262     } catch (...) {
67263       {
67264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67265       };
67266     }
67267   }
67268
67269   jresult = (void *)result;
67270   return jresult;
67271 }
67272
67273
67274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67275   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67276
67277   arg1 = (Dali::Toolkit::Control *)jarg1;
67278   {
67279     try {
67280       delete arg1;
67281     } catch (std::out_of_range& e) {
67282       {
67283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67284       };
67285     } catch (std::exception& e) {
67286       {
67287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67288       };
67289     } catch (Dali::DaliException e) {
67290       {
67291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67292       };
67293     } catch (...) {
67294       {
67295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67296       };
67297     }
67298   }
67299
67300 }
67301
67302
67303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67304   void * jresult ;
67305   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67306   Dali::Toolkit::Control *arg2 = 0 ;
67307   Dali::Toolkit::Control *result = 0 ;
67308
67309   arg1 = (Dali::Toolkit::Control *)jarg1;
67310   arg2 = (Dali::Toolkit::Control *)jarg2;
67311   if (!arg2) {
67312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67313     return 0;
67314   }
67315   {
67316     try {
67317       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67318     } catch (std::out_of_range& e) {
67319       {
67320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67321       };
67322     } catch (std::exception& e) {
67323       {
67324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67325       };
67326     } catch (Dali::DaliException e) {
67327       {
67328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67329       };
67330     } catch (...) {
67331       {
67332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67333       };
67334     }
67335   }
67336
67337   jresult = (void *)result;
67338   return jresult;
67339 }
67340
67341
67342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67343   void * jresult ;
67344   Dali::BaseHandle arg1 ;
67345   Dali::BaseHandle *argp1 ;
67346   Dali::Toolkit::Control result;
67347
67348   argp1 = (Dali::BaseHandle *)jarg1;
67349   if (!argp1) {
67350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67351     return 0;
67352   }
67353   arg1 = *argp1;
67354   {
67355     try {
67356       result = Dali::Toolkit::Control::DownCast(arg1);
67357     } catch (std::out_of_range& e) {
67358       {
67359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67360       };
67361     } catch (std::exception& e) {
67362       {
67363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67364       };
67365     } catch (Dali::DaliException e) {
67366       {
67367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67368       };
67369     } catch (...) {
67370       {
67371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67372       };
67373     }
67374   }
67375
67376   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67377   return jresult;
67378 }
67379
67380
67381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67382   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67383
67384   arg1 = (Dali::Toolkit::Control *)jarg1;
67385   {
67386     try {
67387       (arg1)->SetKeyInputFocus();
67388     } catch (std::out_of_range& e) {
67389       {
67390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67391       };
67392     } catch (std::exception& e) {
67393       {
67394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67395       };
67396     } catch (Dali::DaliException e) {
67397       {
67398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67399       };
67400     } catch (...) {
67401       {
67402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67403       };
67404     }
67405   }
67406
67407 }
67408
67409
67410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67411   unsigned int jresult ;
67412   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67413   bool result;
67414
67415   arg1 = (Dali::Toolkit::Control *)jarg1;
67416   {
67417     try {
67418       result = (bool)(arg1)->HasKeyInputFocus();
67419     } catch (std::out_of_range& e) {
67420       {
67421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67422       };
67423     } catch (std::exception& e) {
67424       {
67425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67426       };
67427     } catch (Dali::DaliException e) {
67428       {
67429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67430       };
67431     } catch (...) {
67432       {
67433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67434       };
67435     }
67436   }
67437
67438   jresult = result;
67439   return jresult;
67440 }
67441
67442
67443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67444   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67445
67446   arg1 = (Dali::Toolkit::Control *)jarg1;
67447   {
67448     try {
67449       (arg1)->ClearKeyInputFocus();
67450     } catch (std::out_of_range& e) {
67451       {
67452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67453       };
67454     } catch (std::exception& e) {
67455       {
67456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67457       };
67458     } catch (Dali::DaliException e) {
67459       {
67460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67461       };
67462     } catch (...) {
67463       {
67464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67465       };
67466     }
67467   }
67468
67469 }
67470
67471
67472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67473   void * jresult ;
67474   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67475   Dali::PinchGestureDetector result;
67476
67477   arg1 = (Dali::Toolkit::Control *)jarg1;
67478   {
67479     try {
67480       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67481     } catch (std::out_of_range& e) {
67482       {
67483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67484       };
67485     } catch (std::exception& e) {
67486       {
67487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67488       };
67489     } catch (Dali::DaliException e) {
67490       {
67491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67492       };
67493     } catch (...) {
67494       {
67495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67496       };
67497     }
67498   }
67499
67500   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67501   return jresult;
67502 }
67503
67504
67505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67506   void * jresult ;
67507   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67508   Dali::PanGestureDetector result;
67509
67510   arg1 = (Dali::Toolkit::Control *)jarg1;
67511   {
67512     try {
67513       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67514     } catch (std::out_of_range& e) {
67515       {
67516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67517       };
67518     } catch (std::exception& e) {
67519       {
67520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67521       };
67522     } catch (Dali::DaliException e) {
67523       {
67524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67525       };
67526     } catch (...) {
67527       {
67528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67529       };
67530     }
67531   }
67532
67533   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67534   return jresult;
67535 }
67536
67537
67538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67539   void * jresult ;
67540   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67541   Dali::TapGestureDetector result;
67542
67543   arg1 = (Dali::Toolkit::Control *)jarg1;
67544   {
67545     try {
67546       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67547     } catch (std::out_of_range& e) {
67548       {
67549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67550       };
67551     } catch (std::exception& e) {
67552       {
67553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67554       };
67555     } catch (Dali::DaliException e) {
67556       {
67557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67558       };
67559     } catch (...) {
67560       {
67561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67562       };
67563     }
67564   }
67565
67566   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67567   return jresult;
67568 }
67569
67570
67571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67572   void * jresult ;
67573   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67574   Dali::LongPressGestureDetector result;
67575
67576   arg1 = (Dali::Toolkit::Control *)jarg1;
67577   {
67578     try {
67579       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67580     } catch (std::out_of_range& e) {
67581       {
67582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67583       };
67584     } catch (std::exception& e) {
67585       {
67586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67587       };
67588     } catch (Dali::DaliException e) {
67589       {
67590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67591       };
67592     } catch (...) {
67593       {
67594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67595       };
67596     }
67597   }
67598
67599   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67600   return jresult;
67601 }
67602
67603
67604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67605   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67606   std::string *arg2 = 0 ;
67607
67608   arg1 = (Dali::Toolkit::Control *)jarg1;
67609   if (!jarg2) {
67610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67611     return ;
67612   }
67613   std::string arg2_str(jarg2);
67614   arg2 = &arg2_str;
67615   {
67616     try {
67617       (arg1)->SetStyleName((std::string const &)*arg2);
67618     } catch (std::out_of_range& e) {
67619       {
67620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67621       };
67622     } catch (std::exception& e) {
67623       {
67624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67625       };
67626     } catch (Dali::DaliException e) {
67627       {
67628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67629       };
67630     } catch (...) {
67631       {
67632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67633       };
67634     }
67635   }
67636
67637
67638   //argout typemap for const std::string&
67639
67640 }
67641
67642
67643 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67644   char * jresult ;
67645   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67646   std::string *result = 0 ;
67647
67648   arg1 = (Dali::Toolkit::Control *)jarg1;
67649   {
67650     try {
67651       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67652     } catch (std::out_of_range& e) {
67653       {
67654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67655       };
67656     } catch (std::exception& e) {
67657       {
67658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67659       };
67660     } catch (Dali::DaliException e) {
67661       {
67662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67663       };
67664     } catch (...) {
67665       {
67666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67667       };
67668     }
67669   }
67670
67671   jresult = SWIG_csharp_string_callback(result->c_str());
67672   return jresult;
67673 }
67674
67675
67676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67677   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67678   Dali::Vector4 *arg2 = 0 ;
67679
67680   arg1 = (Dali::Toolkit::Control *)jarg1;
67681   arg2 = (Dali::Vector4 *)jarg2;
67682   if (!arg2) {
67683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67684     return ;
67685   }
67686   {
67687     try {
67688       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67689     } catch (std::out_of_range& e) {
67690       {
67691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67692       };
67693     } catch (std::exception& e) {
67694       {
67695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67696       };
67697     } catch (Dali::DaliException e) {
67698       {
67699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67700       };
67701     } catch (...) {
67702       {
67703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67704       };
67705     }
67706   }
67707
67708 }
67709
67710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67711   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67712
67713   arg1 = (Dali::Toolkit::Control *)jarg1;
67714   {
67715     try {
67716       (arg1)->ClearBackground();
67717     } catch (std::out_of_range& e) {
67718       {
67719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67720       };
67721     } catch (std::exception& e) {
67722       {
67723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67724       };
67725     } catch (Dali::DaliException e) {
67726       {
67727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67728       };
67729     } catch (...) {
67730       {
67731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67732       };
67733     }
67734   }
67735
67736 }
67737
67738
67739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67740   void * jresult ;
67741   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67742   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67743
67744   arg1 = (Dali::Toolkit::Control *)jarg1;
67745   {
67746     try {
67747       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67748     } catch (std::out_of_range& e) {
67749       {
67750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67751       };
67752     } catch (std::exception& e) {
67753       {
67754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67755       };
67756     } catch (Dali::DaliException e) {
67757       {
67758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67759       };
67760     } catch (...) {
67761       {
67762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67763       };
67764     }
67765   }
67766
67767   jresult = (void *)result;
67768   return jresult;
67769 }
67770
67771
67772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67773   void * jresult ;
67774   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67775   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67776
67777   arg1 = (Dali::Toolkit::Control *)jarg1;
67778   {
67779     try {
67780       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67781     } catch (std::out_of_range& e) {
67782       {
67783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67784       };
67785     } catch (std::exception& e) {
67786       {
67787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67788       };
67789     } catch (Dali::DaliException e) {
67790       {
67791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67792       };
67793     } catch (...) {
67794       {
67795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67796       };
67797     }
67798   }
67799
67800   jresult = (void *)result;
67801   return jresult;
67802 }
67803
67804
67805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67806   void * jresult ;
67807   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67808   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67809
67810   arg1 = (Dali::Toolkit::Control *)jarg1;
67811   {
67812     try {
67813       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67814     } catch (std::out_of_range& e) {
67815       {
67816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67817       };
67818     } catch (std::exception& e) {
67819       {
67820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67821       };
67822     } catch (Dali::DaliException e) {
67823       {
67824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67825       };
67826     } catch (...) {
67827       {
67828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67829       };
67830     }
67831   }
67832
67833   jresult = (void *)result;
67834   return jresult;
67835 }
67836
67837
67838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67839   void * jresult ;
67840   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67841   Dali::Toolkit::Control *result = 0 ;
67842
67843   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67844   if (!arg1) {
67845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67846     return 0;
67847   }
67848   {
67849     try {
67850       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67851     } catch (std::out_of_range& e) {
67852       {
67853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67854       };
67855     } catch (std::exception& e) {
67856       {
67857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67858       };
67859     } catch (Dali::DaliException e) {
67860       {
67861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67862       };
67863     } catch (...) {
67864       {
67865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67866       };
67867     }
67868   }
67869
67870   jresult = (void *)result;
67871   return jresult;
67872 }
67873
67874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67875 {
67876   int jresult;
67877   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67878   arg1 = (Dali::Toolkit::Control *)jarg1;
67879
67880   if (!arg1) {
67881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67882     return 0;
67883   }
67884
67885   Dali::Property::Index arg2 = 0 ;
67886   arg2 = (Dali::Property::Index)jarg2;
67887
67888   Toolkit::Visual::ResourceStatus result;
67889   {
67890     try {
67891       result = arg1->GetVisualResourceStatus(arg2);
67892     } catch (std::out_of_range& e) {
67893       {
67894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67895       };
67896     } catch (std::exception& e) {
67897       {
67898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67899       };
67900     } catch (...) {
67901       {
67902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67903       };
67904     }
67905   }
67906   jresult = (int)(result);
67907   return jresult;
67908 }
67909
67910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67911 {
67912   void * jresult;
67913   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67914   arg1 = (Dali::Toolkit::Control *)jarg1;
67915
67916   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67917
67918   Dali::Toolkit::TransitionData *arg2 = 0 ;
67919   Dali::Animation result;
67920
67921   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67922   if (!arg2) {
67923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67924     return 0;
67925   }
67926   {
67927     try {
67928       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67929     } catch (std::out_of_range& e) {
67930       {
67931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67932       };
67933     } catch (std::exception& e) {
67934       {
67935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67936       };
67937     } catch (Dali::DaliException e) {
67938       {
67939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67940       };
67941     } catch (...) {
67942       {
67943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67944       };
67945     }
67946   }
67947
67948   jresult = new Dali::Animation((const Dali::Animation &)result);
67949   return jresult;
67950 }
67951
67952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67953 {
67954   Dali::Toolkit::Control arg1;
67955   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67956
67957   if (!argp1) {
67958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67959   }
67960   arg1 = *argp1;
67961
67962   Dali::Property::Index arg2 = 0 ;
67963   arg2 = (Dali::Property::Index)jarg2;
67964
67965   Dali::Property::Index arg3 = 0 ;
67966   arg3 = (Dali::Property::Index)jarg3;
67967
67968   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
67969
67970   {
67971     try {
67972       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
67973     } catch (std::out_of_range& e) {
67974       {
67975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67976       };
67977     } catch (std::exception& e) {
67978       {
67979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67980       };
67981     } catch (...) {
67982       {
67983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67984       };
67985     }
67986   }
67987
67988
67989 }
67990
67991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
67992   void * jresult ;
67993   Dali::Toolkit::Control *arg1 = 0 ;
67994   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
67995
67996   arg1 = (Dali::Toolkit::Control *)jarg1;
67997   if (!arg1) {
67998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67999     return 0;
68000   }
68001   {
68002     try {
68003       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68004     } catch (std::out_of_range& e) {
68005       {
68006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68007       };
68008     } catch (std::exception& e) {
68009       {
68010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68011       };
68012     } catch (Dali::DaliException e) {
68013       {
68014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68015       };
68016     } catch (...) {
68017       {
68018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68019       };
68020     }
68021   }
68022
68023   jresult = (void *)result;
68024   return jresult;
68025 }
68026
68027
68028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68029   unsigned int jresult ;
68030   Dali::Toolkit::Control *arg1 = 0 ;
68031   bool result;
68032
68033   arg1 = (Dali::Toolkit::Control *)jarg1;
68034   if (!arg1) {
68035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68036     return 0;
68037   }
68038   {
68039     try {
68040       result = (bool)arg1->IsResourceReady();
68041     } catch (std::out_of_range& e) {
68042       {
68043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68044       };
68045     } catch (std::exception& e) {
68046       {
68047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68048       };
68049     } catch (Dali::DaliException e) {
68050       {
68051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68052       };
68053     } catch (...) {
68054       {
68055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68056       };
68057     }
68058   }
68059
68060   jresult = result;
68061   return jresult;
68062 }
68063
68064
68065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68066   void * jresult ;
68067   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68068
68069   {
68070     try {
68071       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68072     } catch (std::out_of_range& e) {
68073       {
68074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68075       };
68076     } catch (std::exception& e) {
68077       {
68078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68079       };
68080     } catch (Dali::DaliException e) {
68081       {
68082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68083       };
68084     } catch (...) {
68085       {
68086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68087       };
68088     }
68089   }
68090
68091   jresult = (void *)result;
68092   return jresult;
68093 }
68094
68095
68096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68097   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68098
68099   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68100   {
68101     try {
68102       delete arg1;
68103     } catch (std::out_of_range& e) {
68104       {
68105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68106       };
68107     } catch (std::exception& e) {
68108       {
68109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68110       };
68111     } catch (Dali::DaliException e) {
68112       {
68113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68114       };
68115     } catch (...) {
68116       {
68117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68118       };
68119     }
68120   }
68121
68122 }
68123
68124
68125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68126   void * jresult ;
68127   Dali::Toolkit::KeyInputFocusManager result;
68128
68129   {
68130     try {
68131       result = Dali::Toolkit::KeyInputFocusManager::Get();
68132     } catch (std::out_of_range& e) {
68133       {
68134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68135       };
68136     } catch (std::exception& e) {
68137       {
68138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68139       };
68140     } catch (Dali::DaliException e) {
68141       {
68142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68143       };
68144     } catch (...) {
68145       {
68146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68147       };
68148     }
68149   }
68150
68151   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68152   return jresult;
68153 }
68154
68155
68156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68157   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68158   Dali::Toolkit::Control arg2 ;
68159   Dali::Toolkit::Control *argp2 ;
68160
68161   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68162   argp2 = (Dali::Toolkit::Control *)jarg2;
68163   if (!argp2) {
68164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68165     return ;
68166   }
68167   arg2 = *argp2;
68168   {
68169     try {
68170       (arg1)->SetFocus(arg2);
68171     } catch (std::out_of_range& e) {
68172       {
68173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68174       };
68175     } catch (std::exception& e) {
68176       {
68177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68178       };
68179     } catch (Dali::DaliException e) {
68180       {
68181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68182       };
68183     } catch (...) {
68184       {
68185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68186       };
68187     }
68188   }
68189
68190 }
68191
68192
68193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68194   void * jresult ;
68195   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68196   Dali::Toolkit::Control result;
68197
68198   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68199   {
68200     try {
68201       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68202     } catch (std::out_of_range& e) {
68203       {
68204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68205       };
68206     } catch (std::exception& e) {
68207       {
68208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68209       };
68210     } catch (Dali::DaliException e) {
68211       {
68212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68213       };
68214     } catch (...) {
68215       {
68216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68217       };
68218     }
68219   }
68220
68221   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68222   return jresult;
68223 }
68224
68225
68226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68227   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68228   Dali::Toolkit::Control arg2 ;
68229   Dali::Toolkit::Control *argp2 ;
68230
68231   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68232   argp2 = (Dali::Toolkit::Control *)jarg2;
68233   if (!argp2) {
68234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68235     return ;
68236   }
68237   arg2 = *argp2;
68238   {
68239     try {
68240       (arg1)->RemoveFocus(arg2);
68241     } catch (std::out_of_range& e) {
68242       {
68243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68244       };
68245     } catch (std::exception& e) {
68246       {
68247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68248       };
68249     } catch (Dali::DaliException e) {
68250       {
68251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68252       };
68253     } catch (...) {
68254       {
68255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68256       };
68257     }
68258   }
68259
68260 }
68261
68262
68263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68264   void * jresult ;
68265   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68266   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68267
68268   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68269   {
68270     try {
68271       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68272     } catch (std::out_of_range& e) {
68273       {
68274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68275       };
68276     } catch (std::exception& e) {
68277       {
68278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68279       };
68280     } catch (Dali::DaliException e) {
68281       {
68282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68283       };
68284     } catch (...) {
68285       {
68286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68287       };
68288     }
68289   }
68290
68291   jresult = (void *)result;
68292   return jresult;
68293 }
68294
68295
68296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68297   void * jresult ;
68298   Dali::Toolkit::Alignment::Padding *result = 0 ;
68299
68300   {
68301     try {
68302       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68303     } catch (std::out_of_range& e) {
68304       {
68305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68306       };
68307     } catch (std::exception& e) {
68308       {
68309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68310       };
68311     } catch (Dali::DaliException e) {
68312       {
68313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68314       };
68315     } catch (...) {
68316       {
68317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68318       };
68319     }
68320   }
68321
68322   jresult = (void *)result;
68323   return jresult;
68324 }
68325
68326
68327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68328   void * jresult ;
68329   float arg1 ;
68330   float arg2 ;
68331   float arg3 ;
68332   float arg4 ;
68333   Dali::Toolkit::Alignment::Padding *result = 0 ;
68334
68335   arg1 = (float)jarg1;
68336   arg2 = (float)jarg2;
68337   arg3 = (float)jarg3;
68338   arg4 = (float)jarg4;
68339   {
68340     try {
68341       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68342     } catch (std::out_of_range& e) {
68343       {
68344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68345       };
68346     } catch (std::exception& e) {
68347       {
68348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68349       };
68350     } catch (Dali::DaliException e) {
68351       {
68352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68353       };
68354     } catch (...) {
68355       {
68356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68357       };
68358     }
68359   }
68360
68361   jresult = (void *)result;
68362   return jresult;
68363 }
68364
68365
68366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68367   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68368   float arg2 ;
68369
68370   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68371   arg2 = (float)jarg2;
68372   if (arg1) (arg1)->left = arg2;
68373 }
68374
68375
68376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68377   float jresult ;
68378   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68379   float result;
68380
68381   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68382   result = (float) ((arg1)->left);
68383   jresult = result;
68384   return jresult;
68385 }
68386
68387
68388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68389   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68390   float arg2 ;
68391
68392   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68393   arg2 = (float)jarg2;
68394   if (arg1) (arg1)->right = arg2;
68395 }
68396
68397
68398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68399   float jresult ;
68400   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68401   float result;
68402
68403   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68404   result = (float) ((arg1)->right);
68405   jresult = result;
68406   return jresult;
68407 }
68408
68409
68410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68411   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68412   float arg2 ;
68413
68414   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68415   arg2 = (float)jarg2;
68416   if (arg1) (arg1)->top = arg2;
68417 }
68418
68419
68420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68421   float jresult ;
68422   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68423   float result;
68424
68425   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68426   result = (float) ((arg1)->top);
68427   jresult = result;
68428   return jresult;
68429 }
68430
68431
68432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68433   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68434   float arg2 ;
68435
68436   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68437   arg2 = (float)jarg2;
68438   if (arg1) (arg1)->bottom = arg2;
68439 }
68440
68441
68442 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68443   float jresult ;
68444   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68445   float result;
68446
68447   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68448   result = (float) ((arg1)->bottom);
68449   jresult = result;
68450   return jresult;
68451 }
68452
68453
68454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68455   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68456
68457   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68458   {
68459     try {
68460       delete arg1;
68461     } catch (std::out_of_range& e) {
68462       {
68463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68464       };
68465     } catch (std::exception& e) {
68466       {
68467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68468       };
68469     } catch (Dali::DaliException e) {
68470       {
68471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68472       };
68473     } catch (...) {
68474       {
68475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68476       };
68477     }
68478   }
68479
68480 }
68481
68482
68483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68484   void * jresult ;
68485   Dali::Toolkit::Alignment *result = 0 ;
68486
68487   {
68488     try {
68489       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68490     } catch (std::out_of_range& e) {
68491       {
68492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68493       };
68494     } catch (std::exception& e) {
68495       {
68496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68497       };
68498     } catch (Dali::DaliException e) {
68499       {
68500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68501       };
68502     } catch (...) {
68503       {
68504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68505       };
68506     }
68507   }
68508
68509   jresult = (void *)result;
68510   return jresult;
68511 }
68512
68513
68514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68515   void * jresult ;
68516   Dali::Toolkit::Alignment::Type arg1 ;
68517   Dali::Toolkit::Alignment::Type arg2 ;
68518   Dali::Toolkit::Alignment result;
68519
68520   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68521   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68522   {
68523     try {
68524       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68525     } catch (std::out_of_range& e) {
68526       {
68527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68528       };
68529     } catch (std::exception& e) {
68530       {
68531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68532       };
68533     } catch (Dali::DaliException e) {
68534       {
68535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68536       };
68537     } catch (...) {
68538       {
68539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68540       };
68541     }
68542   }
68543
68544   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68545   return jresult;
68546 }
68547
68548
68549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68550   void * jresult ;
68551   Dali::Toolkit::Alignment::Type arg1 ;
68552   Dali::Toolkit::Alignment result;
68553
68554   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68555   {
68556     try {
68557       result = Dali::Toolkit::Alignment::New(arg1);
68558     } catch (std::out_of_range& e) {
68559       {
68560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68561       };
68562     } catch (std::exception& e) {
68563       {
68564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68565       };
68566     } catch (Dali::DaliException e) {
68567       {
68568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68569       };
68570     } catch (...) {
68571       {
68572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68573       };
68574     }
68575   }
68576
68577   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68578   return jresult;
68579 }
68580
68581
68582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68583   void * jresult ;
68584   Dali::Toolkit::Alignment result;
68585
68586   {
68587     try {
68588       result = Dali::Toolkit::Alignment::New();
68589     } catch (std::out_of_range& e) {
68590       {
68591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68592       };
68593     } catch (std::exception& e) {
68594       {
68595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68596       };
68597     } catch (Dali::DaliException e) {
68598       {
68599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68600       };
68601     } catch (...) {
68602       {
68603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68604       };
68605     }
68606   }
68607
68608   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68609   return jresult;
68610 }
68611
68612
68613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68614   void * jresult ;
68615   Dali::Toolkit::Alignment *arg1 = 0 ;
68616   Dali::Toolkit::Alignment *result = 0 ;
68617
68618   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68619   if (!arg1) {
68620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68621     return 0;
68622   }
68623   {
68624     try {
68625       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68626     } catch (std::out_of_range& e) {
68627       {
68628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68629       };
68630     } catch (std::exception& e) {
68631       {
68632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68633       };
68634     } catch (Dali::DaliException e) {
68635       {
68636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68637       };
68638     } catch (...) {
68639       {
68640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68641       };
68642     }
68643   }
68644
68645   jresult = (void *)result;
68646   return jresult;
68647 }
68648
68649
68650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68651   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68652
68653   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68654   {
68655     try {
68656       delete arg1;
68657     } catch (std::out_of_range& e) {
68658       {
68659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68660       };
68661     } catch (std::exception& e) {
68662       {
68663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68664       };
68665     } catch (Dali::DaliException e) {
68666       {
68667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68668       };
68669     } catch (...) {
68670       {
68671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68672       };
68673     }
68674   }
68675
68676 }
68677
68678
68679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68680   void * jresult ;
68681   Dali::BaseHandle arg1 ;
68682   Dali::BaseHandle *argp1 ;
68683   Dali::Toolkit::Alignment result;
68684
68685   argp1 = (Dali::BaseHandle *)jarg1;
68686   if (!argp1) {
68687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68688     return 0;
68689   }
68690   arg1 = *argp1;
68691   {
68692     try {
68693       result = Dali::Toolkit::Alignment::DownCast(arg1);
68694     } catch (std::out_of_range& e) {
68695       {
68696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68697       };
68698     } catch (std::exception& e) {
68699       {
68700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68701       };
68702     } catch (Dali::DaliException e) {
68703       {
68704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68705       };
68706     } catch (...) {
68707       {
68708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68709       };
68710     }
68711   }
68712
68713   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68714   return jresult;
68715 }
68716
68717
68718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68719   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68720   Dali::Toolkit::Alignment::Type arg2 ;
68721
68722   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68723   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68724   {
68725     try {
68726       (arg1)->SetAlignmentType(arg2);
68727     } catch (std::out_of_range& e) {
68728       {
68729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68730       };
68731     } catch (std::exception& e) {
68732       {
68733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68734       };
68735     } catch (Dali::DaliException e) {
68736       {
68737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68738       };
68739     } catch (...) {
68740       {
68741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68742       };
68743     }
68744   }
68745
68746 }
68747
68748
68749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68750   int jresult ;
68751   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68752   Dali::Toolkit::Alignment::Type result;
68753
68754   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68755   {
68756     try {
68757       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68758     } catch (std::out_of_range& e) {
68759       {
68760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68761       };
68762     } catch (std::exception& e) {
68763       {
68764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68765       };
68766     } catch (Dali::DaliException e) {
68767       {
68768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68769       };
68770     } catch (...) {
68771       {
68772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68773       };
68774     }
68775   }
68776
68777   jresult = (int)result;
68778   return jresult;
68779 }
68780
68781
68782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68783   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68784   Dali::Toolkit::Alignment::Scaling arg2 ;
68785
68786   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68787   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68788   {
68789     try {
68790       (arg1)->SetScaling(arg2);
68791     } catch (std::out_of_range& e) {
68792       {
68793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68794       };
68795     } catch (std::exception& e) {
68796       {
68797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68798       };
68799     } catch (Dali::DaliException e) {
68800       {
68801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68802       };
68803     } catch (...) {
68804       {
68805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68806       };
68807     }
68808   }
68809
68810 }
68811
68812
68813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68814   int jresult ;
68815   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68816   Dali::Toolkit::Alignment::Scaling result;
68817
68818   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68819   {
68820     try {
68821       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68822     } catch (std::out_of_range& e) {
68823       {
68824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68825       };
68826     } catch (std::exception& e) {
68827       {
68828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68829       };
68830     } catch (Dali::DaliException e) {
68831       {
68832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68833       };
68834     } catch (...) {
68835       {
68836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68837       };
68838     }
68839   }
68840
68841   jresult = (int)result;
68842   return jresult;
68843 }
68844
68845
68846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68847   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68848   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68849
68850   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68851   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68852   if (!arg2) {
68853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68854     return ;
68855   }
68856   {
68857     try {
68858       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68859     } catch (std::out_of_range& e) {
68860       {
68861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68862       };
68863     } catch (std::exception& e) {
68864       {
68865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68866       };
68867     } catch (Dali::DaliException e) {
68868       {
68869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68870       };
68871     } catch (...) {
68872       {
68873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68874       };
68875     }
68876   }
68877
68878 }
68879
68880
68881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68882   void * jresult ;
68883   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68884   Dali::Toolkit::Alignment::Padding *result = 0 ;
68885
68886   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68887   {
68888     try {
68889       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68890     } catch (std::out_of_range& e) {
68891       {
68892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68893       };
68894     } catch (std::exception& e) {
68895       {
68896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68897       };
68898     } catch (Dali::DaliException e) {
68899       {
68900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68901       };
68902     } catch (...) {
68903       {
68904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68905       };
68906     }
68907   }
68908
68909   jresult = (void *)result;
68910   return jresult;
68911 }
68912
68913
68914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68915   void * jresult ;
68916   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68917   Dali::Toolkit::Alignment *arg2 = 0 ;
68918   Dali::Toolkit::Alignment *result = 0 ;
68919
68920   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68921   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68922   if (!arg2) {
68923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68924     return 0;
68925   }
68926   {
68927     try {
68928       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68929     } catch (std::out_of_range& e) {
68930       {
68931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68932       };
68933     } catch (std::exception& e) {
68934       {
68935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68936       };
68937     } catch (Dali::DaliException e) {
68938       {
68939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68940       };
68941     } catch (...) {
68942       {
68943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68944       };
68945     }
68946   }
68947
68948   jresult = (void *)result;
68949   return jresult;
68950 }
68951
68952
68953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68954   int jresult ;
68955   int result;
68956
68957   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68958   jresult = (int)result;
68959   return jresult;
68960 }
68961
68962
68963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68964   int jresult ;
68965   int result;
68966
68967   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68968   jresult = (int)result;
68969   return jresult;
68970 }
68971
68972
68973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68974   int jresult ;
68975   int result;
68976
68977   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
68978   jresult = (int)result;
68979   return jresult;
68980 }
68981
68982
68983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
68984   int jresult ;
68985   int result;
68986
68987   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
68988   jresult = (int)result;
68989   return jresult;
68990 }
68991
68992
68993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
68994   int jresult ;
68995   int result;
68996
68997   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
68998   jresult = (int)result;
68999   return jresult;
69000 }
69001
69002
69003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69004   int jresult ;
69005   int result;
69006
69007   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69008   jresult = (int)result;
69009   return jresult;
69010 }
69011
69012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69013   int jresult ;
69014   int result;
69015
69016   result = (int)Dali::Toolkit::Button::Property::LABEL;
69017   jresult = (int)result;
69018   return jresult;
69019 }
69020
69021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69022   void * jresult ;
69023   Dali::Toolkit::Button::Property *result = 0 ;
69024
69025   {
69026     try {
69027       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69028     } catch (std::out_of_range& e) {
69029       {
69030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69031       };
69032     } catch (std::exception& e) {
69033       {
69034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69035       };
69036     } catch (Dali::DaliException e) {
69037       {
69038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69039       };
69040     } catch (...) {
69041       {
69042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69043       };
69044     }
69045   }
69046
69047   jresult = (void *)result;
69048   return jresult;
69049 }
69050
69051
69052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69053   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69054
69055   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69056   {
69057     try {
69058       delete arg1;
69059     } catch (std::out_of_range& e) {
69060       {
69061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69062       };
69063     } catch (std::exception& e) {
69064       {
69065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69066       };
69067     } catch (Dali::DaliException e) {
69068       {
69069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69070       };
69071     } catch (...) {
69072       {
69073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69074       };
69075     }
69076   }
69077
69078 }
69079
69080
69081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69082   void * jresult ;
69083   Dali::Toolkit::Button *result = 0 ;
69084
69085   {
69086     try {
69087       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69088     } catch (std::out_of_range& e) {
69089       {
69090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69091       };
69092     } catch (std::exception& e) {
69093       {
69094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69095       };
69096     } catch (Dali::DaliException e) {
69097       {
69098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69099       };
69100     } catch (...) {
69101       {
69102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69103       };
69104     }
69105   }
69106
69107   jresult = (void *)result;
69108   return jresult;
69109 }
69110
69111
69112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69113   void * jresult ;
69114   Dali::Toolkit::Button *arg1 = 0 ;
69115   Dali::Toolkit::Button *result = 0 ;
69116
69117   arg1 = (Dali::Toolkit::Button *)jarg1;
69118   if (!arg1) {
69119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69120     return 0;
69121   }
69122   {
69123     try {
69124       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69125     } catch (std::out_of_range& e) {
69126       {
69127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69128       };
69129     } catch (std::exception& e) {
69130       {
69131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69132       };
69133     } catch (Dali::DaliException e) {
69134       {
69135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69136       };
69137     } catch (...) {
69138       {
69139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69140       };
69141     }
69142   }
69143
69144   jresult = (void *)result;
69145   return jresult;
69146 }
69147
69148
69149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69150   void * jresult ;
69151   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69152   Dali::Toolkit::Button *arg2 = 0 ;
69153   Dali::Toolkit::Button *result = 0 ;
69154
69155   arg1 = (Dali::Toolkit::Button *)jarg1;
69156   arg2 = (Dali::Toolkit::Button *)jarg2;
69157   if (!arg2) {
69158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69159     return 0;
69160   }
69161   {
69162     try {
69163       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69164     } catch (std::out_of_range& e) {
69165       {
69166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69167       };
69168     } catch (std::exception& e) {
69169       {
69170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69171       };
69172     } catch (Dali::DaliException e) {
69173       {
69174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69175       };
69176     } catch (...) {
69177       {
69178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69179       };
69180     }
69181   }
69182
69183   jresult = (void *)result;
69184   return jresult;
69185 }
69186
69187
69188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69189   void * jresult ;
69190   Dali::BaseHandle arg1 ;
69191   Dali::BaseHandle *argp1 ;
69192   Dali::Toolkit::Button result;
69193
69194   argp1 = (Dali::BaseHandle *)jarg1;
69195   if (!argp1) {
69196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69197     return 0;
69198   }
69199   arg1 = *argp1;
69200   {
69201     try {
69202       result = Dali::Toolkit::Button::DownCast(arg1);
69203     } catch (std::out_of_range& e) {
69204       {
69205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69206       };
69207     } catch (std::exception& e) {
69208       {
69209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (Dali::DaliException e) {
69212       {
69213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69214       };
69215     } catch (...) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69218       };
69219     }
69220   }
69221
69222   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69223   return jresult;
69224 }
69225
69226
69227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69228   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69229
69230   arg1 = (Dali::Toolkit::Button *)jarg1;
69231   {
69232     try {
69233       delete arg1;
69234     } catch (std::out_of_range& e) {
69235       {
69236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69237       };
69238     } catch (std::exception& e) {
69239       {
69240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69241       };
69242     } catch (Dali::DaliException e) {
69243       {
69244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69245       };
69246     } catch (...) {
69247       {
69248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69249       };
69250     }
69251   }
69252
69253 }
69254
69255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69256   void * jresult ;
69257   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69258   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69259
69260   arg1 = (Dali::Toolkit::Button *)jarg1;
69261   {
69262     try {
69263       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69264     } catch (std::out_of_range& e) {
69265       {
69266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69267       };
69268     } catch (std::exception& e) {
69269       {
69270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69271       };
69272     } catch (Dali::DaliException e) {
69273       {
69274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69275       };
69276     } catch (...) {
69277       {
69278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69279       };
69280     }
69281   }
69282
69283   jresult = (void *)result;
69284   return jresult;
69285 }
69286
69287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69288   void * jresult ;
69289   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69290   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69291
69292   arg1 = (Dali::Toolkit::Button *)jarg1;
69293   {
69294     try {
69295       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69296     } catch (std::out_of_range& e) {
69297       {
69298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69299       };
69300     } catch (std::exception& e) {
69301       {
69302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69303       };
69304     } catch (Dali::DaliException e) {
69305       {
69306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69307       };
69308     } catch (...) {
69309       {
69310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69311       };
69312     }
69313   }
69314
69315   jresult = (void *)result;
69316   return jresult;
69317 }
69318
69319
69320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69321   void * jresult ;
69322   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69323   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69324
69325   arg1 = (Dali::Toolkit::Button *)jarg1;
69326   {
69327     try {
69328       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69329     } catch (std::out_of_range& e) {
69330       {
69331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69332       };
69333     } catch (std::exception& e) {
69334       {
69335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69336       };
69337     } catch (Dali::DaliException e) {
69338       {
69339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69340       };
69341     } catch (...) {
69342       {
69343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69344       };
69345     }
69346   }
69347
69348   jresult = (void *)result;
69349   return jresult;
69350 }
69351
69352
69353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69354   void * jresult ;
69355   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69356   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69357
69358   arg1 = (Dali::Toolkit::Button *)jarg1;
69359   {
69360     try {
69361       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69362     } catch (std::out_of_range& e) {
69363       {
69364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69365       };
69366     } catch (std::exception& e) {
69367       {
69368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69369       };
69370     } catch (Dali::DaliException e) {
69371       {
69372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69373       };
69374     } catch (...) {
69375       {
69376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69377       };
69378     }
69379   }
69380
69381   jresult = (void *)result;
69382   return jresult;
69383 }
69384
69385
69386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69387   void * jresult ;
69388   Dali::Toolkit::CheckBoxButton *result = 0 ;
69389
69390   {
69391     try {
69392       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69393     } catch (std::out_of_range& e) {
69394       {
69395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69396       };
69397     } catch (std::exception& e) {
69398       {
69399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69400       };
69401     } catch (Dali::DaliException e) {
69402       {
69403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69404       };
69405     } catch (...) {
69406       {
69407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69408       };
69409     }
69410   }
69411
69412   jresult = (void *)result;
69413   return jresult;
69414 }
69415
69416
69417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69418   void * jresult ;
69419   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69420   Dali::Toolkit::CheckBoxButton *result = 0 ;
69421
69422   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69423   if (!arg1) {
69424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69425     return 0;
69426   }
69427   {
69428     try {
69429       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69430     } catch (std::out_of_range& e) {
69431       {
69432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69433       };
69434     } catch (std::exception& e) {
69435       {
69436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69437       };
69438     } catch (Dali::DaliException e) {
69439       {
69440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69441       };
69442     } catch (...) {
69443       {
69444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69445       };
69446     }
69447   }
69448
69449   jresult = (void *)result;
69450   return jresult;
69451 }
69452
69453
69454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69455   void * jresult ;
69456   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69457   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69458   Dali::Toolkit::CheckBoxButton *result = 0 ;
69459
69460   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69461   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69462   if (!arg2) {
69463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69464     return 0;
69465   }
69466   {
69467     try {
69468       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69469     } catch (std::out_of_range& e) {
69470       {
69471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69472       };
69473     } catch (std::exception& e) {
69474       {
69475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69476       };
69477     } catch (Dali::DaliException e) {
69478       {
69479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69480       };
69481     } catch (...) {
69482       {
69483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69484       };
69485     }
69486   }
69487
69488   jresult = (void *)result;
69489   return jresult;
69490 }
69491
69492
69493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
69494   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69495
69496   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69497   {
69498     try {
69499       delete arg1;
69500     } catch (std::out_of_range& e) {
69501       {
69502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69503       };
69504     } catch (std::exception& e) {
69505       {
69506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69507       };
69508     } catch (Dali::DaliException e) {
69509       {
69510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69511       };
69512     } catch (...) {
69513       {
69514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69515       };
69516     }
69517   }
69518
69519 }
69520
69521
69522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
69523   void * jresult ;
69524   Dali::Toolkit::CheckBoxButton result;
69525
69526   {
69527     try {
69528       result = Dali::Toolkit::CheckBoxButton::New();
69529     } catch (std::out_of_range& e) {
69530       {
69531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69532       };
69533     } catch (std::exception& e) {
69534       {
69535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69536       };
69537     } catch (Dali::DaliException e) {
69538       {
69539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69540       };
69541     } catch (...) {
69542       {
69543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69544       };
69545     }
69546   }
69547
69548   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69549   return jresult;
69550 }
69551
69552
69553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
69554   void * jresult ;
69555   Dali::BaseHandle arg1 ;
69556   Dali::BaseHandle *argp1 ;
69557   Dali::Toolkit::CheckBoxButton result;
69558
69559   argp1 = (Dali::BaseHandle *)jarg1;
69560   if (!argp1) {
69561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69562     return 0;
69563   }
69564   arg1 = *argp1;
69565   {
69566     try {
69567       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
69568     } catch (std::out_of_range& e) {
69569       {
69570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69571       };
69572     } catch (std::exception& e) {
69573       {
69574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69575       };
69576     } catch (Dali::DaliException e) {
69577       {
69578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69579       };
69580     } catch (...) {
69581       {
69582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69583       };
69584     }
69585   }
69586
69587   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69588   return jresult;
69589 }
69590
69591
69592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
69593   int jresult ;
69594   int result;
69595
69596   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
69597   jresult = (int)result;
69598   return jresult;
69599 }
69600
69601
69602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
69603   int jresult ;
69604   int result;
69605
69606   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
69607   jresult = (int)result;
69608   return jresult;
69609 }
69610
69611
69612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
69613   int jresult ;
69614   int result;
69615
69616   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
69617   jresult = (int)result;
69618   return jresult;
69619 }
69620
69621
69622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
69623   int jresult ;
69624   int result;
69625
69626   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
69627   jresult = (int)result;
69628   return jresult;
69629 }
69630
69631
69632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
69633   int jresult ;
69634   int result;
69635
69636   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
69637   jresult = (int)result;
69638   return jresult;
69639 }
69640
69641
69642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
69643   void * jresult ;
69644   Dali::Toolkit::PushButton::Property *result = 0 ;
69645
69646   {
69647     try {
69648       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
69649     } catch (std::out_of_range& e) {
69650       {
69651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69652       };
69653     } catch (std::exception& e) {
69654       {
69655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69656       };
69657     } catch (Dali::DaliException e) {
69658       {
69659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69660       };
69661     } catch (...) {
69662       {
69663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69664       };
69665     }
69666   }
69667
69668   jresult = (void *)result;
69669   return jresult;
69670 }
69671
69672
69673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
69674   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
69675
69676   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
69677   {
69678     try {
69679       delete arg1;
69680     } catch (std::out_of_range& e) {
69681       {
69682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69683       };
69684     } catch (std::exception& e) {
69685       {
69686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69687       };
69688     } catch (Dali::DaliException e) {
69689       {
69690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69691       };
69692     } catch (...) {
69693       {
69694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69695       };
69696     }
69697   }
69698
69699 }
69700
69701
69702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
69703   void * jresult ;
69704   Dali::Toolkit::PushButton *result = 0 ;
69705
69706   {
69707     try {
69708       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
69709     } catch (std::out_of_range& e) {
69710       {
69711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69712       };
69713     } catch (std::exception& e) {
69714       {
69715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69716       };
69717     } catch (Dali::DaliException e) {
69718       {
69719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69720       };
69721     } catch (...) {
69722       {
69723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69724       };
69725     }
69726   }
69727
69728   jresult = (void *)result;
69729   return jresult;
69730 }
69731
69732
69733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
69734   void * jresult ;
69735   Dali::Toolkit::PushButton *arg1 = 0 ;
69736   Dali::Toolkit::PushButton *result = 0 ;
69737
69738   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69739   if (!arg1) {
69740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69741     return 0;
69742   }
69743   {
69744     try {
69745       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
69746     } catch (std::out_of_range& e) {
69747       {
69748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69749       };
69750     } catch (std::exception& e) {
69751       {
69752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69753       };
69754     } catch (Dali::DaliException e) {
69755       {
69756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69757       };
69758     } catch (...) {
69759       {
69760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69761       };
69762     }
69763   }
69764
69765   jresult = (void *)result;
69766   return jresult;
69767 }
69768
69769
69770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
69771   void * jresult ;
69772   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69773   Dali::Toolkit::PushButton *arg2 = 0 ;
69774   Dali::Toolkit::PushButton *result = 0 ;
69775
69776   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69777   arg2 = (Dali::Toolkit::PushButton *)jarg2;
69778   if (!arg2) {
69779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69780     return 0;
69781   }
69782   {
69783     try {
69784       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
69785     } catch (std::out_of_range& e) {
69786       {
69787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69788       };
69789     } catch (std::exception& e) {
69790       {
69791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69792       };
69793     } catch (Dali::DaliException e) {
69794       {
69795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69796       };
69797     } catch (...) {
69798       {
69799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69800       };
69801     }
69802   }
69803
69804   jresult = (void *)result;
69805   return jresult;
69806 }
69807
69808
69809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
69810   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69811
69812   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69813   {
69814     try {
69815       delete arg1;
69816     } catch (std::out_of_range& e) {
69817       {
69818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69819       };
69820     } catch (std::exception& e) {
69821       {
69822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69823       };
69824     } catch (Dali::DaliException e) {
69825       {
69826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69827       };
69828     } catch (...) {
69829       {
69830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69831       };
69832     }
69833   }
69834
69835 }
69836
69837
69838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
69839   void * jresult ;
69840   Dali::Toolkit::PushButton result;
69841
69842   {
69843     try {
69844       result = Dali::Toolkit::PushButton::New();
69845     } catch (std::out_of_range& e) {
69846       {
69847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69848       };
69849     } catch (std::exception& e) {
69850       {
69851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69852       };
69853     } catch (Dali::DaliException e) {
69854       {
69855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69856       };
69857     } catch (...) {
69858       {
69859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69860       };
69861     }
69862   }
69863
69864   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69865   return jresult;
69866 }
69867
69868
69869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
69870   void * jresult ;
69871   Dali::BaseHandle arg1 ;
69872   Dali::BaseHandle *argp1 ;
69873   Dali::Toolkit::PushButton result;
69874
69875   argp1 = (Dali::BaseHandle *)jarg1;
69876   if (!argp1) {
69877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69878     return 0;
69879   }
69880   arg1 = *argp1;
69881   {
69882     try {
69883       result = Dali::Toolkit::PushButton::DownCast(arg1);
69884     } catch (std::out_of_range& e) {
69885       {
69886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69887       };
69888     } catch (std::exception& e) {
69889       {
69890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69891       };
69892     } catch (Dali::DaliException e) {
69893       {
69894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69895       };
69896     } catch (...) {
69897       {
69898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69899       };
69900     }
69901   }
69902
69903   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69904   return jresult;
69905 }
69906
69907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
69908   void * jresult ;
69909   Dali::Toolkit::RadioButton *result = 0 ;
69910
69911   {
69912     try {
69913       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
69914     } catch (std::out_of_range& e) {
69915       {
69916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69917       };
69918     } catch (std::exception& e) {
69919       {
69920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69921       };
69922     } catch (Dali::DaliException e) {
69923       {
69924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69925       };
69926     } catch (...) {
69927       {
69928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69929       };
69930     }
69931   }
69932
69933   jresult = (void *)result;
69934   return jresult;
69935 }
69936
69937
69938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
69939   void * jresult ;
69940   Dali::Toolkit::RadioButton *arg1 = 0 ;
69941   Dali::Toolkit::RadioButton *result = 0 ;
69942
69943   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69944   if (!arg1) {
69945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69946     return 0;
69947   }
69948   {
69949     try {
69950       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
69951     } catch (std::out_of_range& e) {
69952       {
69953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69954       };
69955     } catch (std::exception& e) {
69956       {
69957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69958       };
69959     } catch (Dali::DaliException e) {
69960       {
69961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69962       };
69963     } catch (...) {
69964       {
69965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69966       };
69967     }
69968   }
69969
69970   jresult = (void *)result;
69971   return jresult;
69972 }
69973
69974
69975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
69976   void * jresult ;
69977   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69978   Dali::Toolkit::RadioButton *arg2 = 0 ;
69979   Dali::Toolkit::RadioButton *result = 0 ;
69980
69981   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69982   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
69983   if (!arg2) {
69984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69985     return 0;
69986   }
69987   {
69988     try {
69989       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
69990     } catch (std::out_of_range& e) {
69991       {
69992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69993       };
69994     } catch (std::exception& e) {
69995       {
69996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69997       };
69998     } catch (Dali::DaliException e) {
69999       {
70000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70001       };
70002     } catch (...) {
70003       {
70004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70005       };
70006     }
70007   }
70008
70009   jresult = (void *)result;
70010   return jresult;
70011 }
70012
70013
70014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
70015   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70016
70017   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70018   {
70019     try {
70020       delete arg1;
70021     } catch (std::out_of_range& e) {
70022       {
70023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70024       };
70025     } catch (std::exception& e) {
70026       {
70027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70028       };
70029     } catch (Dali::DaliException e) {
70030       {
70031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70032       };
70033     } catch (...) {
70034       {
70035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70036       };
70037     }
70038   }
70039
70040 }
70041
70042
70043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
70044   void * jresult ;
70045   Dali::Toolkit::RadioButton result;
70046
70047   {
70048     try {
70049       result = Dali::Toolkit::RadioButton::New();
70050     } catch (std::out_of_range& e) {
70051       {
70052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70053       };
70054     } catch (std::exception& e) {
70055       {
70056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70057       };
70058     } catch (Dali::DaliException e) {
70059       {
70060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70061       };
70062     } catch (...) {
70063       {
70064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70065       };
70066     }
70067   }
70068
70069   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70070   return jresult;
70071 }
70072
70073
70074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
70075   void * jresult ;
70076   std::string *arg1 = 0 ;
70077   Dali::Toolkit::RadioButton result;
70078
70079   if (!jarg1) {
70080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70081     return 0;
70082   }
70083   std::string arg1_str(jarg1);
70084   arg1 = &arg1_str;
70085   {
70086     try {
70087       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70088     } catch (std::out_of_range& e) {
70089       {
70090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70091       };
70092     } catch (std::exception& e) {
70093       {
70094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70095       };
70096     } catch (Dali::DaliException e) {
70097       {
70098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70099       };
70100     } catch (...) {
70101       {
70102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70103       };
70104     }
70105   }
70106
70107   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70108
70109   //argout typemap for const std::string&
70110
70111   return jresult;
70112 }
70113
70114
70115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70116   void * jresult ;
70117   Dali::BaseHandle arg1 ;
70118   Dali::BaseHandle *argp1 ;
70119   Dali::Toolkit::RadioButton result;
70120
70121   argp1 = (Dali::BaseHandle *)jarg1;
70122   if (!argp1) {
70123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70124     return 0;
70125   }
70126   arg1 = *argp1;
70127   {
70128     try {
70129       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70130     } catch (std::out_of_range& e) {
70131       {
70132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70133       };
70134     } catch (std::exception& e) {
70135       {
70136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70137       };
70138     } catch (Dali::DaliException e) {
70139       {
70140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70141       };
70142     } catch (...) {
70143       {
70144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70145       };
70146     }
70147   }
70148
70149   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70150   return jresult;
70151 }
70152
70153
70154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70155   int jresult ;
70156   int result;
70157
70158   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
70159   jresult = (int)result;
70160   return jresult;
70161 }
70162
70163
70164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
70165   int jresult ;
70166   int result;
70167
70168   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
70169   jresult = (int)result;
70170   return jresult;
70171 }
70172
70173
70174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
70175   int jresult ;
70176   int result;
70177
70178   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
70179   jresult = (int)result;
70180   return jresult;
70181 }
70182
70183
70184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
70185   int jresult ;
70186   int result;
70187
70188   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
70189   jresult = (int)result;
70190   return jresult;
70191 }
70192
70193
70194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
70195   int jresult ;
70196   int result;
70197
70198   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
70199   jresult = (int)result;
70200   return jresult;
70201 }
70202
70203
70204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
70205   int jresult ;
70206   int result;
70207
70208   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
70209   jresult = (int)result;
70210   return jresult;
70211 }
70212
70213
70214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
70215   void * jresult ;
70216   Dali::Toolkit::FlexContainer::Property *result = 0 ;
70217
70218   {
70219     try {
70220       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
70221     } catch (std::out_of_range& e) {
70222       {
70223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70224       };
70225     } catch (std::exception& e) {
70226       {
70227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70228       };
70229     } catch (Dali::DaliException e) {
70230       {
70231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70232       };
70233     } catch (...) {
70234       {
70235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70236       };
70237     }
70238   }
70239
70240   jresult = (void *)result;
70241   return jresult;
70242 }
70243
70244
70245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
70246   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
70247
70248   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
70249   {
70250     try {
70251       delete arg1;
70252     } catch (std::out_of_range& e) {
70253       {
70254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70255       };
70256     } catch (std::exception& e) {
70257       {
70258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70259       };
70260     } catch (Dali::DaliException e) {
70261       {
70262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70263       };
70264     } catch (...) {
70265       {
70266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70267       };
70268     }
70269   }
70270
70271 }
70272
70273
70274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
70275   int jresult ;
70276   int result;
70277
70278   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
70279   jresult = (int)result;
70280   return jresult;
70281 }
70282
70283
70284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
70285   int jresult ;
70286   int result;
70287
70288   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
70289   jresult = (int)result;
70290   return jresult;
70291 }
70292
70293
70294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
70295   int jresult ;
70296   int result;
70297
70298   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
70299   jresult = (int)result;
70300   return jresult;
70301 }
70302
70303
70304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
70305   void * jresult ;
70306   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
70307
70308   {
70309     try {
70310       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
70311     } catch (std::out_of_range& e) {
70312       {
70313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70314       };
70315     } catch (std::exception& e) {
70316       {
70317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70318       };
70319     } catch (Dali::DaliException e) {
70320       {
70321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70322       };
70323     } catch (...) {
70324       {
70325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70326       };
70327     }
70328   }
70329
70330   jresult = (void *)result;
70331   return jresult;
70332 }
70333
70334
70335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
70336   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
70337
70338   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
70339   {
70340     try {
70341       delete arg1;
70342     } catch (std::out_of_range& e) {
70343       {
70344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70345       };
70346     } catch (std::exception& e) {
70347       {
70348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70349       };
70350     } catch (Dali::DaliException e) {
70351       {
70352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70353       };
70354     } catch (...) {
70355       {
70356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70357       };
70358     }
70359   }
70360
70361 }
70362
70363
70364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
70365   void * jresult ;
70366   Dali::Toolkit::FlexContainer *result = 0 ;
70367
70368   {
70369     try {
70370       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
70371     } catch (std::out_of_range& e) {
70372       {
70373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70374       };
70375     } catch (std::exception& e) {
70376       {
70377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70378       };
70379     } catch (Dali::DaliException e) {
70380       {
70381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70382       };
70383     } catch (...) {
70384       {
70385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70386       };
70387     }
70388   }
70389
70390   jresult = (void *)result;
70391   return jresult;
70392 }
70393
70394
70395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
70396   void * jresult ;
70397   Dali::Toolkit::FlexContainer *arg1 = 0 ;
70398   Dali::Toolkit::FlexContainer *result = 0 ;
70399
70400   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70401   if (!arg1) {
70402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70403     return 0;
70404   }
70405   {
70406     try {
70407       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
70408     } catch (std::out_of_range& e) {
70409       {
70410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70411       };
70412     } catch (std::exception& e) {
70413       {
70414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70415       };
70416     } catch (Dali::DaliException e) {
70417       {
70418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70419       };
70420     } catch (...) {
70421       {
70422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70423       };
70424     }
70425   }
70426
70427   jresult = (void *)result;
70428   return jresult;
70429 }
70430
70431
70432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
70433   void * jresult ;
70434   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70435   Dali::Toolkit::FlexContainer *arg2 = 0 ;
70436   Dali::Toolkit::FlexContainer *result = 0 ;
70437
70438   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70439   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
70440   if (!arg2) {
70441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70442     return 0;
70443   }
70444   {
70445     try {
70446       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
70447     } catch (std::out_of_range& e) {
70448       {
70449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70450       };
70451     } catch (std::exception& e) {
70452       {
70453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70454       };
70455     } catch (Dali::DaliException e) {
70456       {
70457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70458       };
70459     } catch (...) {
70460       {
70461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70462       };
70463     }
70464   }
70465
70466   jresult = (void *)result;
70467   return jresult;
70468 }
70469
70470
70471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
70472   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70473
70474   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70475   {
70476     try {
70477       delete arg1;
70478     } catch (std::out_of_range& e) {
70479       {
70480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70481       };
70482     } catch (std::exception& e) {
70483       {
70484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70485       };
70486     } catch (Dali::DaliException e) {
70487       {
70488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70489       };
70490     } catch (...) {
70491       {
70492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70493       };
70494     }
70495   }
70496
70497 }
70498
70499
70500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
70501   void * jresult ;
70502   Dali::Toolkit::FlexContainer result;
70503
70504   {
70505     try {
70506       result = Dali::Toolkit::FlexContainer::New();
70507     } catch (std::out_of_range& e) {
70508       {
70509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70510       };
70511     } catch (std::exception& e) {
70512       {
70513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70514       };
70515     } catch (Dali::DaliException e) {
70516       {
70517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70518       };
70519     } catch (...) {
70520       {
70521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70522       };
70523     }
70524   }
70525
70526   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70527   return jresult;
70528 }
70529
70530
70531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
70532   void * jresult ;
70533   Dali::BaseHandle arg1 ;
70534   Dali::BaseHandle *argp1 ;
70535   Dali::Toolkit::FlexContainer result;
70536
70537   argp1 = (Dali::BaseHandle *)jarg1;
70538   if (!argp1) {
70539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70540     return 0;
70541   }
70542   arg1 = *argp1;
70543   {
70544     try {
70545       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
70546     } catch (std::out_of_range& e) {
70547       {
70548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70549       };
70550     } catch (std::exception& e) {
70551       {
70552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70553       };
70554     } catch (Dali::DaliException e) {
70555       {
70556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70557       };
70558     } catch (...) {
70559       {
70560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70561       };
70562     }
70563   }
70564
70565   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70566   return jresult;
70567 }
70568
70569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
70570   int jresult ;
70571   int result;
70572
70573   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
70574   jresult = (int)result;
70575   return jresult;
70576 }
70577
70578
70579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
70580   int jresult ;
70581   int result;
70582
70583   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
70584   jresult = (int)result;
70585   return jresult;
70586 }
70587
70588
70589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
70590   int jresult ;
70591   int result;
70592
70593   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
70594   jresult = (int)result;
70595   return jresult;
70596 }
70597
70598
70599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
70600   void * jresult ;
70601   Dali::Toolkit::ImageView::Property *result = 0 ;
70602
70603   {
70604     try {
70605       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
70606     } catch (std::out_of_range& e) {
70607       {
70608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70609       };
70610     } catch (std::exception& e) {
70611       {
70612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70613       };
70614     } catch (Dali::DaliException e) {
70615       {
70616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70617       };
70618     } catch (...) {
70619       {
70620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70621       };
70622     }
70623   }
70624
70625   jresult = (void *)result;
70626   return jresult;
70627 }
70628
70629
70630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
70631   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
70632
70633   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
70634   {
70635     try {
70636       delete arg1;
70637     } catch (std::out_of_range& e) {
70638       {
70639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70640       };
70641     } catch (std::exception& e) {
70642       {
70643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70644       };
70645     } catch (Dali::DaliException e) {
70646       {
70647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70648       };
70649     } catch (...) {
70650       {
70651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70652       };
70653     }
70654   }
70655
70656 }
70657
70658
70659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
70660   void * jresult ;
70661   Dali::Toolkit::ImageView *result = 0 ;
70662
70663   {
70664     try {
70665       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
70666     } catch (std::out_of_range& e) {
70667       {
70668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70669       };
70670     } catch (std::exception& e) {
70671       {
70672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70673       };
70674     } catch (Dali::DaliException e) {
70675       {
70676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70677       };
70678     } catch (...) {
70679       {
70680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70681       };
70682     }
70683   }
70684
70685   jresult = (void *)result;
70686   return jresult;
70687 }
70688
70689
70690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
70691   void * jresult ;
70692   Dali::Toolkit::ImageView result;
70693
70694   {
70695     try {
70696       result = Dali::Toolkit::ImageView::New();
70697     } catch (std::out_of_range& e) {
70698       {
70699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70700       };
70701     } catch (std::exception& e) {
70702       {
70703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70704       };
70705     } catch (Dali::DaliException e) {
70706       {
70707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70708       };
70709     } catch (...) {
70710       {
70711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70712       };
70713     }
70714   }
70715
70716   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70717   return jresult;
70718 }
70719
70720
70721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
70722   void * jresult ;
70723   Dali::Image arg1 ;
70724   Dali::Image *argp1 ;
70725   Dali::Toolkit::ImageView result;
70726
70727   argp1 = (Dali::Image *)jarg1;
70728   if (!argp1) {
70729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70730     return 0;
70731   }
70732   arg1 = *argp1;
70733   {
70734     try {
70735       result = Dali::Toolkit::ImageView::New(arg1);
70736     } catch (std::out_of_range& e) {
70737       {
70738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70739       };
70740     } catch (std::exception& e) {
70741       {
70742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70743       };
70744     } catch (Dali::DaliException e) {
70745       {
70746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70747       };
70748     } catch (...) {
70749       {
70750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70751       };
70752     }
70753   }
70754
70755   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70756   return jresult;
70757 }
70758
70759
70760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
70761   void * jresult ;
70762   std::string *arg1 = 0 ;
70763   Dali::Toolkit::ImageView result;
70764
70765   if (!jarg1) {
70766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70767     return 0;
70768   }
70769   std::string arg1_str(jarg1);
70770   arg1 = &arg1_str;
70771   {
70772     try {
70773       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
70774     } catch (std::out_of_range& e) {
70775       {
70776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70777       };
70778     } catch (std::exception& e) {
70779       {
70780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70781       };
70782     } catch (Dali::DaliException e) {
70783       {
70784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70785       };
70786     } catch (...) {
70787       {
70788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70789       };
70790     }
70791   }
70792
70793   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70794
70795   //argout typemap for const std::string&
70796
70797   return jresult;
70798 }
70799
70800
70801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
70802   void * jresult ;
70803   std::string *arg1 = 0 ;
70804   Dali::ImageDimensions arg2 ;
70805   Dali::ImageDimensions *argp2 ;
70806   Dali::Toolkit::ImageView result;
70807
70808   if (!jarg1) {
70809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70810     return 0;
70811   }
70812   std::string arg1_str(jarg1);
70813   arg1 = &arg1_str;
70814   argp2 = (Dali::ImageDimensions *)jarg2;
70815   if (!argp2) {
70816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
70817     return 0;
70818   }
70819   arg2 = *argp2;
70820   {
70821     try {
70822       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
70823     } catch (std::out_of_range& e) {
70824       {
70825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70826       };
70827     } catch (std::exception& e) {
70828       {
70829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70830       };
70831     } catch (Dali::DaliException e) {
70832       {
70833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70834       };
70835     } catch (...) {
70836       {
70837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70838       };
70839     }
70840   }
70841
70842   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70843
70844   //argout typemap for const std::string&
70845
70846   return jresult;
70847 }
70848
70849
70850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
70851   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70852
70853   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70854   {
70855     try {
70856       delete arg1;
70857     } catch (std::out_of_range& e) {
70858       {
70859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70860       };
70861     } catch (std::exception& e) {
70862       {
70863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70864       };
70865     } catch (Dali::DaliException e) {
70866       {
70867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70868       };
70869     } catch (...) {
70870       {
70871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70872       };
70873     }
70874   }
70875
70876 }
70877
70878
70879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
70880   void * jresult ;
70881   Dali::Toolkit::ImageView *arg1 = 0 ;
70882   Dali::Toolkit::ImageView *result = 0 ;
70883
70884   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70885   if (!arg1) {
70886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70887     return 0;
70888   }
70889   {
70890     try {
70891       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
70892     } catch (std::out_of_range& e) {
70893       {
70894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70895       };
70896     } catch (std::exception& e) {
70897       {
70898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70899       };
70900     } catch (Dali::DaliException e) {
70901       {
70902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70903       };
70904     } catch (...) {
70905       {
70906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70907       };
70908     }
70909   }
70910
70911   jresult = (void *)result;
70912   return jresult;
70913 }
70914
70915
70916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
70917   void * jresult ;
70918   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70919   Dali::Toolkit::ImageView *arg2 = 0 ;
70920   Dali::Toolkit::ImageView *result = 0 ;
70921
70922   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70923   arg2 = (Dali::Toolkit::ImageView *)jarg2;
70924   if (!arg2) {
70925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70926     return 0;
70927   }
70928   {
70929     try {
70930       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
70931     } catch (std::out_of_range& e) {
70932       {
70933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70934       };
70935     } catch (std::exception& e) {
70936       {
70937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70938       };
70939     } catch (Dali::DaliException e) {
70940       {
70941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70942       };
70943     } catch (...) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70946       };
70947     }
70948   }
70949
70950   jresult = (void *)result;
70951   return jresult;
70952 }
70953
70954
70955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
70956   void * jresult ;
70957   Dali::BaseHandle arg1 ;
70958   Dali::BaseHandle *argp1 ;
70959   Dali::Toolkit::ImageView result;
70960
70961   argp1 = (Dali::BaseHandle *)jarg1;
70962   if (!argp1) {
70963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70964     return 0;
70965   }
70966   arg1 = *argp1;
70967   {
70968     try {
70969       result = Dali::Toolkit::ImageView::DownCast(arg1);
70970     } catch (std::out_of_range& e) {
70971       {
70972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70973       };
70974     } catch (std::exception& e) {
70975       {
70976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70977       };
70978     } catch (Dali::DaliException e) {
70979       {
70980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70981       };
70982     } catch (...) {
70983       {
70984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70985       };
70986     }
70987   }
70988
70989   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70990   return jresult;
70991 }
70992
70993
70994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
70995   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70996   Dali::Image arg2 ;
70997   Dali::Image *argp2 ;
70998
70999   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71000   argp2 = (Dali::Image *)jarg2;
71001   if (!argp2) {
71002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71003     return ;
71004   }
71005   arg2 = *argp2;
71006   {
71007     try {
71008       (arg1)->SetImage(arg2);
71009     } catch (std::out_of_range& e) {
71010       {
71011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71012       };
71013     } catch (std::exception& e) {
71014       {
71015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71016       };
71017     } catch (Dali::DaliException e) {
71018       {
71019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71020       };
71021     } catch (...) {
71022       {
71023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71024       };
71025     }
71026   }
71027
71028 }
71029
71030
71031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
71032   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71033   std::string *arg2 = 0 ;
71034
71035   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71036   if (!jarg2) {
71037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71038     return ;
71039   }
71040   std::string arg2_str(jarg2);
71041   arg2 = &arg2_str;
71042   {
71043     try {
71044       (arg1)->SetImage((std::string const &)*arg2);
71045     } catch (std::out_of_range& e) {
71046       {
71047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71048       };
71049     } catch (std::exception& e) {
71050       {
71051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71052       };
71053     } catch (Dali::DaliException e) {
71054       {
71055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71056       };
71057     } catch (...) {
71058       {
71059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71060       };
71061     }
71062   }
71063
71064
71065   //argout typemap for const std::string&
71066
71067 }
71068
71069
71070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
71071   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71072   std::string *arg2 = 0 ;
71073   Dali::ImageDimensions arg3 ;
71074   Dali::ImageDimensions *argp3 ;
71075
71076   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71077   if (!jarg2) {
71078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71079     return ;
71080   }
71081   std::string arg2_str(jarg2);
71082   arg2 = &arg2_str;
71083   argp3 = (Dali::ImageDimensions *)jarg3;
71084   if (!argp3) {
71085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71086     return ;
71087   }
71088   arg3 = *argp3;
71089   {
71090     try {
71091       (arg1)->SetImage((std::string const &)*arg2,arg3);
71092     } catch (std::out_of_range& e) {
71093       {
71094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71095       };
71096     } catch (std::exception& e) {
71097       {
71098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71099       };
71100     } catch (Dali::DaliException e) {
71101       {
71102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71103       };
71104     } catch (...) {
71105       {
71106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71107       };
71108     }
71109   }
71110
71111
71112   //argout typemap for const std::string&
71113
71114 }
71115
71116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71117   void * jresult ;
71118   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71119   Dali::Image result;
71120
71121   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71122   {
71123     try {
71124       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71125     } catch (std::out_of_range& e) {
71126       {
71127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71128       };
71129     } catch (std::exception& e) {
71130       {
71131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71132       };
71133     } catch (Dali::DaliException e) {
71134       {
71135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71136       };
71137     } catch (...) {
71138       {
71139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71140       };
71141     }
71142   }
71143
71144   jresult = new Dali::Image((const Dali::Image &)result);
71145   return jresult;
71146 }
71147
71148
71149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
71150   int jresult ;
71151   int result;
71152
71153   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
71154   jresult = (int)result;
71155   return jresult;
71156 }
71157
71158
71159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
71160   int jresult ;
71161   int result;
71162
71163   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
71164   jresult = (int)result;
71165   return jresult;
71166 }
71167
71168
71169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
71170   int jresult ;
71171   int result;
71172
71173   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
71174   jresult = (int)result;
71175   return jresult;
71176 }
71177
71178
71179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
71180   int jresult ;
71181   int result;
71182
71183   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
71184   jresult = (int)result;
71185   return jresult;
71186 }
71187
71188
71189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
71190   int jresult ;
71191   int result;
71192
71193   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
71194   jresult = (int)result;
71195   return jresult;
71196 }
71197
71198
71199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
71200   int jresult ;
71201   int result;
71202
71203   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
71204   jresult = (int)result;
71205   return jresult;
71206 }
71207
71208
71209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
71210   int jresult ;
71211   int result;
71212
71213   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
71214   jresult = (int)result;
71215   return jresult;
71216 }
71217
71218
71219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
71220   int jresult ;
71221   int result;
71222
71223   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
71224   jresult = (int)result;
71225   return jresult;
71226 }
71227
71228
71229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
71230   void * jresult ;
71231   Dali::Toolkit::Model3dView::Property *result = 0 ;
71232
71233   {
71234     try {
71235       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
71236     } catch (std::out_of_range& e) {
71237       {
71238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71239       };
71240     } catch (std::exception& e) {
71241       {
71242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71243       };
71244     } catch (Dali::DaliException e) {
71245       {
71246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71247       };
71248     } catch (...) {
71249       {
71250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71251       };
71252     }
71253   }
71254
71255   jresult = (void *)result;
71256   return jresult;
71257 }
71258
71259
71260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
71261   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
71262
71263   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
71264   {
71265     try {
71266       delete arg1;
71267     } catch (std::out_of_range& e) {
71268       {
71269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71270       };
71271     } catch (std::exception& e) {
71272       {
71273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71274       };
71275     } catch (Dali::DaliException e) {
71276       {
71277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71278       };
71279     } catch (...) {
71280       {
71281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71282       };
71283     }
71284   }
71285
71286 }
71287
71288
71289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
71290   void * jresult ;
71291   Dali::Toolkit::Model3dView result;
71292
71293   {
71294     try {
71295       result = Dali::Toolkit::Model3dView::New();
71296     } catch (std::out_of_range& e) {
71297       {
71298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71299       };
71300     } catch (std::exception& e) {
71301       {
71302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71303       };
71304     } catch (Dali::DaliException e) {
71305       {
71306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71307       };
71308     } catch (...) {
71309       {
71310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71311       };
71312     }
71313   }
71314
71315   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71316   return jresult;
71317 }
71318
71319
71320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
71321   void * jresult ;
71322   std::string *arg1 = 0 ;
71323   std::string *arg2 = 0 ;
71324   std::string *arg3 = 0 ;
71325   Dali::Toolkit::Model3dView result;
71326
71327   if (!jarg1) {
71328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71329     return 0;
71330   }
71331   std::string arg1_str(jarg1);
71332   arg1 = &arg1_str;
71333   if (!jarg2) {
71334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71335     return 0;
71336   }
71337   std::string arg2_str(jarg2);
71338   arg2 = &arg2_str;
71339   if (!jarg3) {
71340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71341     return 0;
71342   }
71343   std::string arg3_str(jarg3);
71344   arg3 = &arg3_str;
71345   {
71346     try {
71347       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
71348     } catch (std::out_of_range& e) {
71349       {
71350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71351       };
71352     } catch (std::exception& e) {
71353       {
71354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71355       };
71356     } catch (Dali::DaliException e) {
71357       {
71358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71359       };
71360     } catch (...) {
71361       {
71362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71363       };
71364     }
71365   }
71366
71367   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71368
71369   //argout typemap for const std::string&
71370
71371
71372   //argout typemap for const std::string&
71373
71374
71375   //argout typemap for const std::string&
71376
71377   return jresult;
71378 }
71379
71380
71381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
71382   void * jresult ;
71383   Dali::Toolkit::Model3dView *result = 0 ;
71384
71385   {
71386     try {
71387       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
71388     } catch (std::out_of_range& e) {
71389       {
71390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71391       };
71392     } catch (std::exception& e) {
71393       {
71394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71395       };
71396     } catch (Dali::DaliException e) {
71397       {
71398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71399       };
71400     } catch (...) {
71401       {
71402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71403       };
71404     }
71405   }
71406
71407   jresult = (void *)result;
71408   return jresult;
71409 }
71410
71411
71412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
71413   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71414
71415   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71416   {
71417     try {
71418       delete arg1;
71419     } catch (std::out_of_range& e) {
71420       {
71421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71422       };
71423     } catch (std::exception& e) {
71424       {
71425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71426       };
71427     } catch (Dali::DaliException e) {
71428       {
71429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71430       };
71431     } catch (...) {
71432       {
71433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71434       };
71435     }
71436   }
71437
71438 }
71439
71440
71441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
71442   void * jresult ;
71443   Dali::Toolkit::Model3dView *arg1 = 0 ;
71444   Dali::Toolkit::Model3dView *result = 0 ;
71445
71446   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71447   if (!arg1) {
71448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71449     return 0;
71450   }
71451   {
71452     try {
71453       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
71454     } catch (std::out_of_range& e) {
71455       {
71456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71457       };
71458     } catch (std::exception& e) {
71459       {
71460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71461       };
71462     } catch (Dali::DaliException e) {
71463       {
71464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71465       };
71466     } catch (...) {
71467       {
71468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71469       };
71470     }
71471   }
71472
71473   jresult = (void *)result;
71474   return jresult;
71475 }
71476
71477
71478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
71479   void * jresult ;
71480   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71481   Dali::Toolkit::Model3dView *arg2 = 0 ;
71482   Dali::Toolkit::Model3dView *result = 0 ;
71483
71484   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71485   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
71486   if (!arg2) {
71487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71488     return 0;
71489   }
71490   {
71491     try {
71492       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
71493     } catch (std::out_of_range& e) {
71494       {
71495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71496       };
71497     } catch (std::exception& e) {
71498       {
71499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71500       };
71501     } catch (Dali::DaliException e) {
71502       {
71503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71504       };
71505     } catch (...) {
71506       {
71507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71508       };
71509     }
71510   }
71511
71512   jresult = (void *)result;
71513   return jresult;
71514 }
71515
71516
71517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
71518   void * jresult ;
71519   Dali::BaseHandle arg1 ;
71520   Dali::BaseHandle *argp1 ;
71521   Dali::Toolkit::Model3dView result;
71522
71523   argp1 = (Dali::BaseHandle *)jarg1;
71524   if (!argp1) {
71525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71526     return 0;
71527   }
71528   arg1 = *argp1;
71529   {
71530     try {
71531       result = Dali::Toolkit::Model3dView::DownCast(arg1);
71532     } catch (std::out_of_range& e) {
71533       {
71534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71535       };
71536     } catch (std::exception& e) {
71537       {
71538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71539       };
71540     } catch (Dali::DaliException e) {
71541       {
71542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71543       };
71544     } catch (...) {
71545       {
71546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71547       };
71548     }
71549   }
71550
71551   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71552   return jresult;
71553 }
71554
71555
71556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
71557   int jresult ;
71558   int result;
71559
71560   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
71561   jresult = (int)result;
71562   return jresult;
71563 }
71564
71565
71566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
71567   int jresult ;
71568   int result;
71569
71570   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
71571   jresult = (int)result;
71572   return jresult;
71573 }
71574
71575
71576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
71577   int jresult ;
71578   int result;
71579
71580   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
71581   jresult = (int)result;
71582   return jresult;
71583 }
71584
71585
71586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
71587   int jresult ;
71588   int result;
71589
71590   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
71591   jresult = (int)result;
71592   return jresult;
71593 }
71594
71595
71596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
71597   int jresult ;
71598   int result;
71599
71600   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
71601   jresult = (int)result;
71602   return jresult;
71603 }
71604
71605
71606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
71607   int jresult ;
71608   int result;
71609
71610   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
71611   jresult = (int)result;
71612   return jresult;
71613 }
71614
71615
71616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
71617   int jresult ;
71618   int result;
71619
71620   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
71621   jresult = (int)result;
71622   return jresult;
71623 }
71624
71625
71626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
71627   int jresult ;
71628   int result;
71629
71630   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
71631   jresult = (int)result;
71632   return jresult;
71633 }
71634
71635
71636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
71637   int jresult ;
71638   int result;
71639
71640   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
71641   jresult = (int)result;
71642   return jresult;
71643 }
71644
71645
71646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
71647   void * jresult ;
71648   Dali::Toolkit::ScrollBar::Property *result = 0 ;
71649
71650   {
71651     try {
71652       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
71653     } catch (std::out_of_range& e) {
71654       {
71655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71656       };
71657     } catch (std::exception& e) {
71658       {
71659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71660       };
71661     } catch (Dali::DaliException e) {
71662       {
71663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71664       };
71665     } catch (...) {
71666       {
71667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71668       };
71669     }
71670   }
71671
71672   jresult = (void *)result;
71673   return jresult;
71674 }
71675
71676
71677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
71678   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
71679
71680   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
71681   {
71682     try {
71683       delete arg1;
71684     } catch (std::out_of_range& e) {
71685       {
71686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71687       };
71688     } catch (std::exception& e) {
71689       {
71690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71691       };
71692     } catch (Dali::DaliException e) {
71693       {
71694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71695       };
71696     } catch (...) {
71697       {
71698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71699       };
71700     }
71701   }
71702
71703 }
71704
71705
71706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
71707   void * jresult ;
71708   Dali::Toolkit::ScrollBar *result = 0 ;
71709
71710   {
71711     try {
71712       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
71713     } catch (std::out_of_range& e) {
71714       {
71715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71716       };
71717     } catch (std::exception& e) {
71718       {
71719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71720       };
71721     } catch (Dali::DaliException e) {
71722       {
71723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71724       };
71725     } catch (...) {
71726       {
71727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71728       };
71729     }
71730   }
71731
71732   jresult = (void *)result;
71733   return jresult;
71734 }
71735
71736
71737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
71738   void * jresult ;
71739   Dali::Toolkit::ScrollBar *arg1 = 0 ;
71740   Dali::Toolkit::ScrollBar *result = 0 ;
71741
71742   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71743   if (!arg1) {
71744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71745     return 0;
71746   }
71747   {
71748     try {
71749       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
71750     } catch (std::out_of_range& e) {
71751       {
71752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71753       };
71754     } catch (std::exception& e) {
71755       {
71756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71757       };
71758     } catch (Dali::DaliException e) {
71759       {
71760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71761       };
71762     } catch (...) {
71763       {
71764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71765       };
71766     }
71767   }
71768
71769   jresult = (void *)result;
71770   return jresult;
71771 }
71772
71773
71774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
71775   void * jresult ;
71776   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71777   Dali::Toolkit::ScrollBar *arg2 = 0 ;
71778   Dali::Toolkit::ScrollBar *result = 0 ;
71779
71780   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71781   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
71782   if (!arg2) {
71783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71784     return 0;
71785   }
71786   {
71787     try {
71788       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
71789     } catch (std::out_of_range& e) {
71790       {
71791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71792       };
71793     } catch (std::exception& e) {
71794       {
71795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71796       };
71797     } catch (Dali::DaliException e) {
71798       {
71799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71800       };
71801     } catch (...) {
71802       {
71803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71804       };
71805     }
71806   }
71807
71808   jresult = (void *)result;
71809   return jresult;
71810 }
71811
71812
71813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
71814   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71815
71816   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71817   {
71818     try {
71819       delete arg1;
71820     } catch (std::out_of_range& e) {
71821       {
71822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71823       };
71824     } catch (std::exception& e) {
71825       {
71826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71827       };
71828     } catch (Dali::DaliException e) {
71829       {
71830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71831       };
71832     } catch (...) {
71833       {
71834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71835       };
71836     }
71837   }
71838
71839 }
71840
71841
71842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
71843   void * jresult ;
71844   Dali::Toolkit::ScrollBar::Direction arg1 ;
71845   Dali::Toolkit::ScrollBar result;
71846
71847   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
71848   {
71849     try {
71850       result = Dali::Toolkit::ScrollBar::New(arg1);
71851     } catch (std::out_of_range& e) {
71852       {
71853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71854       };
71855     } catch (std::exception& e) {
71856       {
71857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71858       };
71859     } catch (Dali::DaliException e) {
71860       {
71861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71862       };
71863     } catch (...) {
71864       {
71865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71866       };
71867     }
71868   }
71869
71870   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71871   return jresult;
71872 }
71873
71874
71875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
71876   void * jresult ;
71877   Dali::Toolkit::ScrollBar result;
71878
71879   {
71880     try {
71881       result = Dali::Toolkit::ScrollBar::New();
71882     } catch (std::out_of_range& e) {
71883       {
71884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71885       };
71886     } catch (std::exception& e) {
71887       {
71888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71889       };
71890     } catch (Dali::DaliException e) {
71891       {
71892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71893       };
71894     } catch (...) {
71895       {
71896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71897       };
71898     }
71899   }
71900
71901   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71902   return jresult;
71903 }
71904
71905
71906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
71907   void * jresult ;
71908   Dali::BaseHandle arg1 ;
71909   Dali::BaseHandle *argp1 ;
71910   Dali::Toolkit::ScrollBar result;
71911
71912   argp1 = (Dali::BaseHandle *)jarg1;
71913   if (!argp1) {
71914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71915     return 0;
71916   }
71917   arg1 = *argp1;
71918   {
71919     try {
71920       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
71921     } catch (std::out_of_range& e) {
71922       {
71923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71924       };
71925     } catch (std::exception& e) {
71926       {
71927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71928       };
71929     } catch (Dali::DaliException e) {
71930       {
71931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71932       };
71933     } catch (...) {
71934       {
71935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71936       };
71937     }
71938   }
71939
71940   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71941   return jresult;
71942 }
71943
71944
71945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
71946   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71947   Dali::Handle arg2 ;
71948   Dali::Property::Index arg3 ;
71949   Dali::Property::Index arg4 ;
71950   Dali::Property::Index arg5 ;
71951   Dali::Property::Index arg6 ;
71952   Dali::Handle *argp2 ;
71953
71954   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71955   argp2 = (Dali::Handle *)jarg2;
71956   if (!argp2) {
71957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
71958     return ;
71959   }
71960   arg2 = *argp2;
71961   arg3 = (Dali::Property::Index)jarg3;
71962   arg4 = (Dali::Property::Index)jarg4;
71963   arg5 = (Dali::Property::Index)jarg5;
71964   arg6 = (Dali::Property::Index)jarg6;
71965   {
71966     try {
71967       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
71968     } catch (std::out_of_range& e) {
71969       {
71970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71971       };
71972     } catch (std::exception& e) {
71973       {
71974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71975       };
71976     } catch (Dali::DaliException e) {
71977       {
71978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71979       };
71980     } catch (...) {
71981       {
71982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71983       };
71984     }
71985   }
71986
71987 }
71988
71989
71990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
71991   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71992   Dali::Actor arg2 ;
71993   Dali::Actor *argp2 ;
71994
71995   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71996   argp2 = (Dali::Actor *)jarg2;
71997   if (!argp2) {
71998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71999     return ;
72000   }
72001   arg2 = *argp2;
72002   {
72003     try {
72004       (arg1)->SetScrollIndicator(arg2);
72005     } catch (std::out_of_range& e) {
72006       {
72007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72008       };
72009     } catch (std::exception& e) {
72010       {
72011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72012       };
72013     } catch (Dali::DaliException e) {
72014       {
72015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72016       };
72017     } catch (...) {
72018       {
72019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72020       };
72021     }
72022   }
72023
72024 }
72025
72026
72027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
72028   void * jresult ;
72029   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72030   Dali::Actor result;
72031
72032   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72033   {
72034     try {
72035       result = (arg1)->GetScrollIndicator();
72036     } catch (std::out_of_range& e) {
72037       {
72038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72039       };
72040     } catch (std::exception& e) {
72041       {
72042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72043       };
72044     } catch (Dali::DaliException e) {
72045       {
72046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72047       };
72048     } catch (...) {
72049       {
72050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72051       };
72052     }
72053   }
72054
72055   jresult = new Dali::Actor((const Dali::Actor &)result);
72056   return jresult;
72057 }
72058
72059
72060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
72061   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72062   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
72063
72064   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72065   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
72066   if (!arg2) {
72067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
72068     return ;
72069   }
72070   {
72071     try {
72072       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
72073     } catch (std::out_of_range& e) {
72074       {
72075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72076       };
72077     } catch (std::exception& e) {
72078       {
72079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72080       };
72081     } catch (Dali::DaliException e) {
72082       {
72083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72084       };
72085     } catch (...) {
72086       {
72087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72088       };
72089     }
72090   }
72091
72092 }
72093
72094
72095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72096   void * jresult ;
72097   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72098
72099   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72100   {
72101     try {
72102       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()));
72103     } catch (std::out_of_range& e) {
72104       {
72105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72106       };
72107     } catch (std::exception& e) {
72108       {
72109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72110       };
72111     } catch (...) {
72112       {
72113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72114       };
72115     }
72116   }
72117   return jresult;
72118 }
72119
72120
72121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72122   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72123   Dali::Toolkit::ScrollBar::Direction arg2 ;
72124
72125   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72126   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72127   {
72128     try {
72129       (arg1)->SetScrollDirection(arg2);
72130     } catch (std::out_of_range& e) {
72131       {
72132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72133       };
72134     } catch (std::exception& e) {
72135       {
72136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72137       };
72138     } catch (Dali::DaliException e) {
72139       {
72140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72141       };
72142     } catch (...) {
72143       {
72144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72145       };
72146     }
72147   }
72148
72149 }
72150
72151
72152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
72153   int jresult ;
72154   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72155   Dali::Toolkit::ScrollBar::Direction result;
72156
72157   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72158   {
72159     try {
72160       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
72161     } catch (std::out_of_range& e) {
72162       {
72163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72164       };
72165     } catch (std::exception& e) {
72166       {
72167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72168       };
72169     } catch (Dali::DaliException e) {
72170       {
72171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72172       };
72173     } catch (...) {
72174       {
72175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72176       };
72177     }
72178   }
72179
72180   jresult = (int)result;
72181   return jresult;
72182 }
72183
72184
72185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
72186   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72187   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
72188
72189   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72190   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
72191   {
72192     try {
72193       (arg1)->SetIndicatorHeightPolicy(arg2);
72194     } catch (std::out_of_range& e) {
72195       {
72196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72197       };
72198     } catch (std::exception& e) {
72199       {
72200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72201       };
72202     } catch (Dali::DaliException e) {
72203       {
72204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72205       };
72206     } catch (...) {
72207       {
72208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72209       };
72210     }
72211   }
72212
72213 }
72214
72215
72216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
72217   int jresult ;
72218   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72219   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
72220
72221   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72222   {
72223     try {
72224       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
72225     } catch (std::out_of_range& e) {
72226       {
72227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72228       };
72229     } catch (std::exception& e) {
72230       {
72231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72232       };
72233     } catch (Dali::DaliException e) {
72234       {
72235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72236       };
72237     } catch (...) {
72238       {
72239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72240       };
72241     }
72242   }
72243
72244   jresult = (int)result;
72245   return jresult;
72246 }
72247
72248
72249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
72250   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72251   float arg2 ;
72252
72253   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72254   arg2 = (float)jarg2;
72255   {
72256     try {
72257       (arg1)->SetIndicatorFixedHeight(arg2);
72258     } catch (std::out_of_range& e) {
72259       {
72260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72261       };
72262     } catch (std::exception& e) {
72263       {
72264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72265       };
72266     } catch (Dali::DaliException e) {
72267       {
72268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72269       };
72270     } catch (...) {
72271       {
72272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72273       };
72274     }
72275   }
72276
72277 }
72278
72279
72280 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
72281   float jresult ;
72282   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72283   float result;
72284
72285   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72286   {
72287     try {
72288       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
72289     } catch (std::out_of_range& e) {
72290       {
72291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72292       };
72293     } catch (std::exception& e) {
72294       {
72295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72296       };
72297     } catch (Dali::DaliException e) {
72298       {
72299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72300       };
72301     } catch (...) {
72302       {
72303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72304       };
72305     }
72306   }
72307
72308   jresult = result;
72309   return jresult;
72310 }
72311
72312
72313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
72314   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72315   float arg2 ;
72316
72317   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72318   arg2 = (float)jarg2;
72319   {
72320     try {
72321       (arg1)->SetIndicatorShowDuration(arg2);
72322     } catch (std::out_of_range& e) {
72323       {
72324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72325       };
72326     } catch (std::exception& e) {
72327       {
72328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72329       };
72330     } catch (Dali::DaliException e) {
72331       {
72332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72333       };
72334     } catch (...) {
72335       {
72336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72337       };
72338     }
72339   }
72340
72341 }
72342
72343
72344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
72345   float jresult ;
72346   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72347   float result;
72348
72349   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72350   {
72351     try {
72352       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
72353     } catch (std::out_of_range& e) {
72354       {
72355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72356       };
72357     } catch (std::exception& e) {
72358       {
72359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72360       };
72361     } catch (Dali::DaliException e) {
72362       {
72363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72364       };
72365     } catch (...) {
72366       {
72367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72368       };
72369     }
72370   }
72371
72372   jresult = result;
72373   return jresult;
72374 }
72375
72376
72377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
72378   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72379   float arg2 ;
72380
72381   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72382   arg2 = (float)jarg2;
72383   {
72384     try {
72385       (arg1)->SetIndicatorHideDuration(arg2);
72386     } catch (std::out_of_range& e) {
72387       {
72388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72389       };
72390     } catch (std::exception& e) {
72391       {
72392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72393       };
72394     } catch (Dali::DaliException e) {
72395       {
72396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72397       };
72398     } catch (...) {
72399       {
72400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72401       };
72402     }
72403   }
72404
72405 }
72406
72407
72408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
72409   float jresult ;
72410   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72411   float result;
72412
72413   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72414   {
72415     try {
72416       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
72417     } catch (std::out_of_range& e) {
72418       {
72419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72420       };
72421     } catch (std::exception& e) {
72422       {
72423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72424       };
72425     } catch (Dali::DaliException e) {
72426       {
72427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72428       };
72429     } catch (...) {
72430       {
72431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72432       };
72433     }
72434   }
72435
72436   jresult = result;
72437   return jresult;
72438 }
72439
72440
72441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
72442   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72443
72444   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72445   {
72446     try {
72447       (arg1)->ShowIndicator();
72448     } catch (std::out_of_range& e) {
72449       {
72450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72451       };
72452     } catch (std::exception& e) {
72453       {
72454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72455       };
72456     } catch (Dali::DaliException e) {
72457       {
72458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72459       };
72460     } catch (...) {
72461       {
72462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72463       };
72464     }
72465   }
72466
72467 }
72468
72469
72470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
72471   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72472
72473   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72474   {
72475     try {
72476       (arg1)->HideIndicator();
72477     } catch (std::out_of_range& e) {
72478       {
72479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72480       };
72481     } catch (std::exception& e) {
72482       {
72483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72484       };
72485     } catch (Dali::DaliException e) {
72486       {
72487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72488       };
72489     } catch (...) {
72490       {
72491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72492       };
72493     }
72494   }
72495
72496 }
72497
72498
72499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
72500   void * jresult ;
72501   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72502   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
72503
72504   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72505   {
72506     try {
72507       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
72508     } catch (std::out_of_range& e) {
72509       {
72510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72511       };
72512     } catch (std::exception& e) {
72513       {
72514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72515       };
72516     } catch (Dali::DaliException e) {
72517       {
72518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72519       };
72520     } catch (...) {
72521       {
72522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72523       };
72524     }
72525   }
72526
72527   jresult = (void *)result;
72528   return jresult;
72529 }
72530
72531
72532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
72533   void * jresult ;
72534   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72535   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
72536
72537   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72538   {
72539     try {
72540       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
72541     } catch (std::out_of_range& e) {
72542       {
72543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72544       };
72545     } catch (std::exception& e) {
72546       {
72547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72548       };
72549     } catch (Dali::DaliException e) {
72550       {
72551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72552       };
72553     } catch (...) {
72554       {
72555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72556       };
72557     }
72558   }
72559
72560   jresult = (void *)result;
72561   return jresult;
72562 }
72563
72564
72565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
72566   int jresult ;
72567   int result;
72568
72569   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
72570   jresult = (int)result;
72571   return jresult;
72572 }
72573
72574
72575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
72576   int jresult ;
72577   int result;
72578
72579   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
72580   jresult = (int)result;
72581   return jresult;
72582 }
72583
72584
72585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
72586   int jresult ;
72587   int result;
72588
72589   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
72590   jresult = (int)result;
72591   return jresult;
72592 }
72593
72594
72595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
72596   int jresult ;
72597   int result;
72598
72599   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
72600   jresult = (int)result;
72601   return jresult;
72602 }
72603
72604
72605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
72606   int jresult ;
72607   int result;
72608
72609   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
72610   jresult = (int)result;
72611   return jresult;
72612 }
72613
72614
72615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
72616   int jresult ;
72617   int result;
72618
72619   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
72620   jresult = (int)result;
72621   return jresult;
72622 }
72623
72624
72625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
72626   int jresult ;
72627   int result;
72628
72629   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
72630   jresult = (int)result;
72631   return jresult;
72632 }
72633
72634
72635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
72636   int jresult ;
72637   int result;
72638
72639   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
72640   jresult = (int)result;
72641   return jresult;
72642 }
72643
72644
72645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
72646   int jresult ;
72647   int result;
72648
72649   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
72650   jresult = (int)result;
72651   return jresult;
72652 }
72653
72654
72655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
72656   int jresult ;
72657   int result;
72658
72659   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
72660   jresult = (int)result;
72661   return jresult;
72662 }
72663
72664
72665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
72666   int jresult ;
72667   int result;
72668
72669   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
72670   jresult = (int)result;
72671   return jresult;
72672 }
72673
72674
72675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
72676   int jresult ;
72677   int result;
72678
72679   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
72680   jresult = (int)result;
72681   return jresult;
72682 }
72683
72684
72685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
72686   int jresult ;
72687   int result;
72688
72689   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
72690   jresult = (int)result;
72691   return jresult;
72692 }
72693
72694
72695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
72696   int jresult ;
72697   int result;
72698
72699   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
72700   jresult = (int)result;
72701   return jresult;
72702 }
72703
72704
72705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
72706   void * jresult ;
72707   Dali::Toolkit::Scrollable::Property *result = 0 ;
72708
72709   {
72710     try {
72711       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
72712     } catch (std::out_of_range& e) {
72713       {
72714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72715       };
72716     } catch (std::exception& e) {
72717       {
72718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72719       };
72720     } catch (Dali::DaliException e) {
72721       {
72722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72723       };
72724     } catch (...) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72727       };
72728     }
72729   }
72730
72731   jresult = (void *)result;
72732   return jresult;
72733 }
72734
72735
72736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
72737   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
72738
72739   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
72740   {
72741     try {
72742       delete arg1;
72743     } catch (std::out_of_range& e) {
72744       {
72745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72746       };
72747     } catch (std::exception& e) {
72748       {
72749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72750       };
72751     } catch (Dali::DaliException e) {
72752       {
72753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72754       };
72755     } catch (...) {
72756       {
72757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72758       };
72759     }
72760   }
72761
72762 }
72763
72764
72765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
72766   void * jresult ;
72767   Dali::Toolkit::Scrollable *result = 0 ;
72768
72769   {
72770     try {
72771       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
72772     } catch (std::out_of_range& e) {
72773       {
72774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72775       };
72776     } catch (std::exception& e) {
72777       {
72778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72779       };
72780     } catch (Dali::DaliException e) {
72781       {
72782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72783       };
72784     } catch (...) {
72785       {
72786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72787       };
72788     }
72789   }
72790
72791   jresult = (void *)result;
72792   return jresult;
72793 }
72794
72795
72796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
72797   void * jresult ;
72798   Dali::Toolkit::Scrollable *arg1 = 0 ;
72799   Dali::Toolkit::Scrollable *result = 0 ;
72800
72801   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72802   if (!arg1) {
72803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72804     return 0;
72805   }
72806   {
72807     try {
72808       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
72809     } catch (std::out_of_range& e) {
72810       {
72811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72812       };
72813     } catch (std::exception& e) {
72814       {
72815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72816       };
72817     } catch (Dali::DaliException e) {
72818       {
72819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72820       };
72821     } catch (...) {
72822       {
72823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72824       };
72825     }
72826   }
72827
72828   jresult = (void *)result;
72829   return jresult;
72830 }
72831
72832
72833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
72834   void * jresult ;
72835   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72836   Dali::Toolkit::Scrollable *arg2 = 0 ;
72837   Dali::Toolkit::Scrollable *result = 0 ;
72838
72839   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72840   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
72841   if (!arg2) {
72842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72843     return 0;
72844   }
72845   {
72846     try {
72847       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
72848     } catch (std::out_of_range& e) {
72849       {
72850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72851       };
72852     } catch (std::exception& e) {
72853       {
72854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72855       };
72856     } catch (Dali::DaliException e) {
72857       {
72858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72859       };
72860     } catch (...) {
72861       {
72862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72863       };
72864     }
72865   }
72866
72867   jresult = (void *)result;
72868   return jresult;
72869 }
72870
72871
72872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
72873   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72874
72875   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72876   {
72877     try {
72878       delete arg1;
72879     } catch (std::out_of_range& e) {
72880       {
72881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72882       };
72883     } catch (std::exception& e) {
72884       {
72885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72886       };
72887     } catch (Dali::DaliException e) {
72888       {
72889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72890       };
72891     } catch (...) {
72892       {
72893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72894       };
72895     }
72896   }
72897
72898 }
72899
72900
72901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
72902   void * jresult ;
72903   Dali::BaseHandle arg1 ;
72904   Dali::BaseHandle *argp1 ;
72905   Dali::Toolkit::Scrollable result;
72906
72907   argp1 = (Dali::BaseHandle *)jarg1;
72908   if (!argp1) {
72909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72910     return 0;
72911   }
72912   arg1 = *argp1;
72913   {
72914     try {
72915       result = Dali::Toolkit::Scrollable::DownCast(arg1);
72916     } catch (std::out_of_range& e) {
72917       {
72918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72919       };
72920     } catch (std::exception& e) {
72921       {
72922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72923       };
72924     } catch (Dali::DaliException e) {
72925       {
72926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72927       };
72928     } catch (...) {
72929       {
72930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72931       };
72932     }
72933   }
72934
72935   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
72936   return jresult;
72937 }
72938
72939
72940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
72941   unsigned int jresult ;
72942   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72943   bool result;
72944
72945   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72946   {
72947     try {
72948       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
72949     } catch (std::out_of_range& e) {
72950       {
72951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72952       };
72953     } catch (std::exception& e) {
72954       {
72955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72956       };
72957     } catch (Dali::DaliException e) {
72958       {
72959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72960       };
72961     } catch (...) {
72962       {
72963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72964       };
72965     }
72966   }
72967
72968   jresult = result;
72969   return jresult;
72970 }
72971
72972
72973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
72974   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72975   bool arg2 ;
72976
72977   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72978   arg2 = jarg2 ? true : false;
72979   {
72980     try {
72981       (arg1)->SetOvershootEnabled(arg2);
72982     } catch (std::out_of_range& e) {
72983       {
72984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72985       };
72986     } catch (std::exception& e) {
72987       {
72988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72989       };
72990     } catch (Dali::DaliException e) {
72991       {
72992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72993       };
72994     } catch (...) {
72995       {
72996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72997       };
72998     }
72999   }
73000
73001 }
73002
73003
73004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
73005   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73006   Dali::Vector4 *arg2 = 0 ;
73007
73008   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73009   arg2 = (Dali::Vector4 *)jarg2;
73010   if (!arg2) {
73011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
73012     return ;
73013   }
73014   {
73015     try {
73016       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
73017     } catch (std::out_of_range& e) {
73018       {
73019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73020       };
73021     } catch (std::exception& e) {
73022       {
73023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73024       };
73025     } catch (Dali::DaliException e) {
73026       {
73027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73028       };
73029     } catch (...) {
73030       {
73031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73032       };
73033     }
73034   }
73035
73036 }
73037
73038
73039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
73040   void * jresult ;
73041   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73042   Dali::Vector4 result;
73043
73044   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73045   {
73046     try {
73047       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
73048     } catch (std::out_of_range& e) {
73049       {
73050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73051       };
73052     } catch (std::exception& e) {
73053       {
73054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73055       };
73056     } catch (Dali::DaliException e) {
73057       {
73058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73059       };
73060     } catch (...) {
73061       {
73062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73063       };
73064     }
73065   }
73066
73067   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
73068   return jresult;
73069 }
73070
73071
73072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
73073   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73074   float arg2 ;
73075
73076   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73077   arg2 = (float)jarg2;
73078   {
73079     try {
73080       (arg1)->SetOvershootAnimationSpeed(arg2);
73081     } catch (std::out_of_range& e) {
73082       {
73083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73084       };
73085     } catch (std::exception& e) {
73086       {
73087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73088       };
73089     } catch (Dali::DaliException e) {
73090       {
73091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73092       };
73093     } catch (...) {
73094       {
73095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73096       };
73097     }
73098   }
73099
73100 }
73101
73102
73103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73104   float jresult ;
73105   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73106   float result;
73107
73108   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73109   {
73110     try {
73111       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73112     } catch (std::out_of_range& e) {
73113       {
73114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73115       };
73116     } catch (std::exception& e) {
73117       {
73118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73119       };
73120     } catch (Dali::DaliException e) {
73121       {
73122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73123       };
73124     } catch (...) {
73125       {
73126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73127       };
73128     }
73129   }
73130
73131   jresult = result;
73132   return jresult;
73133 }
73134
73135
73136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73137   void * jresult ;
73138   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73139   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73140
73141   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73142   {
73143     try {
73144       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73145     } catch (std::out_of_range& e) {
73146       {
73147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73148       };
73149     } catch (std::exception& e) {
73150       {
73151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73152       };
73153     } catch (Dali::DaliException e) {
73154       {
73155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73156       };
73157     } catch (...) {
73158       {
73159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73160       };
73161     }
73162   }
73163
73164   jresult = (void *)result;
73165   return jresult;
73166 }
73167
73168
73169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
73170   void * jresult ;
73171   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73172   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
73173
73174   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73175   {
73176     try {
73177       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
73178     } catch (std::out_of_range& e) {
73179       {
73180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73181       };
73182     } catch (std::exception& e) {
73183       {
73184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73185       };
73186     } catch (Dali::DaliException e) {
73187       {
73188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73189       };
73190     } catch (...) {
73191       {
73192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73193       };
73194     }
73195   }
73196
73197   jresult = (void *)result;
73198   return jresult;
73199 }
73200
73201
73202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
73203   void * jresult ;
73204   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73205   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
73206
73207   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73208   {
73209     try {
73210       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
73211     } catch (std::out_of_range& e) {
73212       {
73213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73214       };
73215     } catch (std::exception& e) {
73216       {
73217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73218       };
73219     } catch (Dali::DaliException e) {
73220       {
73221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73222       };
73223     } catch (...) {
73224       {
73225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73226       };
73227     }
73228   }
73229
73230   jresult = (void *)result;
73231   return jresult;
73232 }
73233
73234
73235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
73236   unsigned int jresult ;
73237   Dali::Toolkit::ControlOrientation::Type arg1 ;
73238   bool result;
73239
73240   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73241   {
73242     try {
73243       result = (bool)Dali::Toolkit::IsVertical(arg1);
73244     } catch (std::out_of_range& e) {
73245       {
73246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73247       };
73248     } catch (std::exception& e) {
73249       {
73250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73251       };
73252     } catch (Dali::DaliException e) {
73253       {
73254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73255       };
73256     } catch (...) {
73257       {
73258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73259       };
73260     }
73261   }
73262
73263   jresult = result;
73264   return jresult;
73265 }
73266
73267
73268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
73269   unsigned int jresult ;
73270   Dali::Toolkit::ControlOrientation::Type arg1 ;
73271   bool result;
73272
73273   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73274   {
73275     try {
73276       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
73277     } catch (std::out_of_range& e) {
73278       {
73279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73280       };
73281     } catch (std::exception& e) {
73282       {
73283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73284       };
73285     } catch (Dali::DaliException e) {
73286       {
73287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73288       };
73289     } catch (...) {
73290       {
73291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73292       };
73293     }
73294   }
73295
73296   jresult = result;
73297   return jresult;
73298 }
73299
73300
73301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
73302   void * jresult ;
73303   unsigned int arg1 ;
73304   unsigned int arg2 ;
73305   Dali::Toolkit::ItemRange *result = 0 ;
73306
73307   arg1 = (unsigned int)jarg1;
73308   arg2 = (unsigned int)jarg2;
73309   {
73310     try {
73311       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
73312     } catch (std::out_of_range& e) {
73313       {
73314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73315       };
73316     } catch (std::exception& e) {
73317       {
73318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73319       };
73320     } catch (Dali::DaliException e) {
73321       {
73322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73323       };
73324     } catch (...) {
73325       {
73326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73327       };
73328     }
73329   }
73330
73331   jresult = (void *)result;
73332   return jresult;
73333 }
73334
73335
73336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
73337   void * jresult ;
73338   Dali::Toolkit::ItemRange *arg1 = 0 ;
73339   Dali::Toolkit::ItemRange *result = 0 ;
73340
73341   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73342   if (!arg1) {
73343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73344     return 0;
73345   }
73346   {
73347     try {
73348       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
73349     } catch (std::out_of_range& e) {
73350       {
73351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73352       };
73353     } catch (std::exception& e) {
73354       {
73355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73356       };
73357     } catch (Dali::DaliException e) {
73358       {
73359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73360       };
73361     } catch (...) {
73362       {
73363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73364       };
73365     }
73366   }
73367
73368   jresult = (void *)result;
73369   return jresult;
73370 }
73371
73372
73373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
73374   void * jresult ;
73375   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73376   Dali::Toolkit::ItemRange *arg2 = 0 ;
73377   Dali::Toolkit::ItemRange *result = 0 ;
73378
73379   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73380   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73381   if (!arg2) {
73382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73383     return 0;
73384   }
73385   {
73386     try {
73387       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
73388     } catch (std::out_of_range& e) {
73389       {
73390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73391       };
73392     } catch (std::exception& e) {
73393       {
73394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73395       };
73396     } catch (Dali::DaliException e) {
73397       {
73398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73399       };
73400     } catch (...) {
73401       {
73402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73403       };
73404     }
73405   }
73406
73407   jresult = (void *)result;
73408   return jresult;
73409 }
73410
73411
73412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
73413   unsigned int jresult ;
73414   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73415   unsigned int arg2 ;
73416   bool result;
73417
73418   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73419   arg2 = (unsigned int)jarg2;
73420   {
73421     try {
73422       result = (bool)(arg1)->Within(arg2);
73423     } catch (std::out_of_range& e) {
73424       {
73425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73426       };
73427     } catch (std::exception& e) {
73428       {
73429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73430       };
73431     } catch (Dali::DaliException e) {
73432       {
73433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73434       };
73435     } catch (...) {
73436       {
73437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73438       };
73439     }
73440   }
73441
73442   jresult = result;
73443   return jresult;
73444 }
73445
73446
73447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
73448   void * jresult ;
73449   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73450   Dali::Toolkit::ItemRange *arg2 = 0 ;
73451   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73452
73453   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73454   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73455   if (!arg2) {
73456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73457     return 0;
73458   }
73459   {
73460     try {
73461       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
73462     } catch (std::out_of_range& e) {
73463       {
73464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73465       };
73466     } catch (std::exception& e) {
73467       {
73468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73469       };
73470     } catch (Dali::DaliException e) {
73471       {
73472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73473       };
73474     } catch (...) {
73475       {
73476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73477       };
73478     }
73479   }
73480
73481   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73482   return jresult;
73483 }
73484
73485
73486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
73487   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73488   unsigned int arg2 ;
73489
73490   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73491   arg2 = (unsigned int)jarg2;
73492   if (arg1) (arg1)->begin = arg2;
73493 }
73494
73495
73496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
73497   unsigned int jresult ;
73498   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73499   unsigned int result;
73500
73501   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73502   result = (unsigned int) ((arg1)->begin);
73503   jresult = result;
73504   return jresult;
73505 }
73506
73507
73508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
73509   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73510   unsigned int arg2 ;
73511
73512   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73513   arg2 = (unsigned int)jarg2;
73514   if (arg1) (arg1)->end = arg2;
73515 }
73516
73517
73518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
73519   unsigned int jresult ;
73520   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73521   unsigned int result;
73522
73523   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73524   result = (unsigned int) ((arg1)->end);
73525   jresult = result;
73526   return jresult;
73527 }
73528
73529
73530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
73531   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73532
73533   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73534   {
73535     try {
73536       delete arg1;
73537     } catch (std::out_of_range& e) {
73538       {
73539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73540       };
73541     } catch (std::exception& e) {
73542       {
73543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73544       };
73545     } catch (Dali::DaliException e) {
73546       {
73547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73548       };
73549     } catch (...) {
73550       {
73551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73552       };
73553     }
73554   }
73555
73556 }
73557
73558
73559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
73560   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73561
73562   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73563   {
73564     try {
73565       delete arg1;
73566     } catch (std::out_of_range& e) {
73567       {
73568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73569       };
73570     } catch (std::exception& e) {
73571       {
73572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73573       };
73574     } catch (Dali::DaliException e) {
73575       {
73576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73577       };
73578     } catch (...) {
73579       {
73580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73581       };
73582     }
73583   }
73584
73585 }
73586
73587
73588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
73589   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73590   Dali::Toolkit::ControlOrientation::Type arg2 ;
73591
73592   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73593   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
73594   {
73595     try {
73596       (arg1)->SetOrientation(arg2);
73597     } catch (std::out_of_range& e) {
73598       {
73599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73600       };
73601     } catch (std::exception& e) {
73602       {
73603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73604       };
73605     } catch (Dali::DaliException e) {
73606       {
73607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73608       };
73609     } catch (...) {
73610       {
73611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73612       };
73613     }
73614   }
73615
73616 }
73617
73618
73619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
73620   int jresult ;
73621   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73622   Dali::Toolkit::ControlOrientation::Type result;
73623
73624   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73625   {
73626     try {
73627       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
73628     } catch (std::out_of_range& e) {
73629       {
73630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73631       };
73632     } catch (std::exception& e) {
73633       {
73634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73635       };
73636     } catch (Dali::DaliException e) {
73637       {
73638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73639       };
73640     } catch (...) {
73641       {
73642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73643       };
73644     }
73645   }
73646
73647   jresult = (int)result;
73648   return jresult;
73649 }
73650
73651
73652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
73653   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73654   Dali::Property::Map *arg2 = 0 ;
73655
73656   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73657   arg2 = (Dali::Property::Map *)jarg2;
73658   if (!arg2) {
73659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
73660     return ;
73661   }
73662   {
73663     try {
73664       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
73665     } catch (std::out_of_range& e) {
73666       {
73667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73668       };
73669     } catch (std::exception& e) {
73670       {
73671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73672       };
73673     } catch (Dali::DaliException e) {
73674       {
73675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73676       };
73677     } catch (...) {
73678       {
73679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73680       };
73681     }
73682   }
73683
73684 }
73685
73686
73687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
73688   void * jresult ;
73689   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73690   Dali::Property::Map result;
73691
73692   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73693   {
73694     try {
73695       result = (arg1)->GetLayoutProperties();
73696     } catch (std::out_of_range& e) {
73697       {
73698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73699       };
73700     } catch (std::exception& e) {
73701       {
73702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73703       };
73704     } catch (Dali::DaliException e) {
73705       {
73706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73707       };
73708     } catch (...) {
73709       {
73710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73711       };
73712     }
73713   }
73714
73715   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
73716   return jresult;
73717 }
73718
73719
73720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73721   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73722   unsigned int arg2 ;
73723   Dali::Vector3 *arg3 = 0 ;
73724   Dali::Vector3 *arg4 = 0 ;
73725
73726   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73727   arg2 = (unsigned int)jarg2;
73728   arg3 = (Dali::Vector3 *)jarg3;
73729   if (!arg3) {
73730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73731     return ;
73732   }
73733   arg4 = (Dali::Vector3 *)jarg4;
73734   if (!arg4) {
73735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73736     return ;
73737   }
73738   {
73739     try {
73740       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73741     } catch (std::out_of_range& e) {
73742       {
73743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73744       };
73745     } catch (std::exception& e) {
73746       {
73747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73748       };
73749     } catch (Dali::DaliException e) {
73750       {
73751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73752       };
73753     } catch (...) {
73754       {
73755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73756       };
73757     }
73758   }
73759
73760 }
73761
73762
73763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
73764   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73765   Dali::Vector3 *arg2 = 0 ;
73766
73767   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73768   arg2 = (Dali::Vector3 *)jarg2;
73769   if (!arg2) {
73770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73771     return ;
73772   }
73773   {
73774     try {
73775       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
73776     } catch (std::out_of_range& e) {
73777       {
73778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73779       };
73780     } catch (std::exception& e) {
73781       {
73782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73783       };
73784     } catch (Dali::DaliException e) {
73785       {
73786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73787       };
73788     } catch (...) {
73789       {
73790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73791       };
73792     }
73793   }
73794
73795 }
73796
73797
73798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
73799   float jresult ;
73800   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73801   unsigned int arg2 ;
73802   Dali::Vector3 arg3 ;
73803   Dali::Vector3 *argp3 ;
73804   float result;
73805
73806   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73807   arg2 = (unsigned int)jarg2;
73808   argp3 = (Dali::Vector3 *)jarg3;
73809   if (!argp3) {
73810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73811     return 0;
73812   }
73813   arg3 = *argp3;
73814   {
73815     try {
73816       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
73817     } catch (std::out_of_range& e) {
73818       {
73819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73820       };
73821     } catch (std::exception& e) {
73822       {
73823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73824       };
73825     } catch (Dali::DaliException e) {
73826       {
73827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73828       };
73829     } catch (...) {
73830       {
73831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73832       };
73833     }
73834   }
73835
73836   jresult = result;
73837   return jresult;
73838 }
73839
73840
73841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
73842   float jresult ;
73843   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73844   float arg2 ;
73845   float result;
73846
73847   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73848   arg2 = (float)jarg2;
73849   {
73850     try {
73851       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
73852     } catch (std::out_of_range& e) {
73853       {
73854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73855       };
73856     } catch (std::exception& e) {
73857       {
73858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73859       };
73860     } catch (Dali::DaliException e) {
73861       {
73862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73863       };
73864     } catch (...) {
73865       {
73866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73867       };
73868     }
73869   }
73870
73871   jresult = result;
73872   return jresult;
73873 }
73874
73875
73876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
73877   float jresult ;
73878   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73879   unsigned int arg2 ;
73880   float result;
73881
73882   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73883   arg2 = (unsigned int)jarg2;
73884   {
73885     try {
73886       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
73887     } catch (std::out_of_range& e) {
73888       {
73889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73890       };
73891     } catch (std::exception& e) {
73892       {
73893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73894       };
73895     } catch (Dali::DaliException e) {
73896       {
73897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73898       };
73899     } catch (...) {
73900       {
73901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73902       };
73903     }
73904   }
73905
73906   jresult = result;
73907   return jresult;
73908 }
73909
73910
73911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
73912   void * jresult ;
73913   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73914   float arg2 ;
73915   Dali::Vector3 arg3 ;
73916   Dali::Vector3 *argp3 ;
73917   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73918
73919   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73920   arg2 = (float)jarg2;
73921   argp3 = (Dali::Vector3 *)jarg3;
73922   if (!argp3) {
73923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73924     return 0;
73925   }
73926   arg3 = *argp3;
73927   {
73928     try {
73929       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
73930     } catch (std::out_of_range& e) {
73931       {
73932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73933       };
73934     } catch (std::exception& e) {
73935       {
73936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73937       };
73938     } catch (Dali::DaliException e) {
73939       {
73940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73941       };
73942     } catch (...) {
73943       {
73944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73945       };
73946     }
73947   }
73948
73949   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73950   return jresult;
73951 }
73952
73953
73954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
73955   float jresult ;
73956   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73957   int arg2 ;
73958   float arg3 ;
73959   Dali::Vector3 *arg4 = 0 ;
73960   float result;
73961
73962   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73963   arg2 = (int)jarg2;
73964   arg3 = (float)jarg3;
73965   arg4 = (Dali::Vector3 *)jarg4;
73966   if (!arg4) {
73967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73968     return 0;
73969   }
73970   {
73971     try {
73972       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
73973     } catch (std::out_of_range& e) {
73974       {
73975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73976       };
73977     } catch (std::exception& e) {
73978       {
73979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73980       };
73981     } catch (Dali::DaliException e) {
73982       {
73983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73984       };
73985     } catch (...) {
73986       {
73987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73988       };
73989     }
73990   }
73991
73992   jresult = result;
73993   return jresult;
73994 }
73995
73996
73997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
73998   unsigned int jresult ;
73999   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74000   Dali::Vector3 arg2 ;
74001   Dali::Vector3 *argp2 ;
74002   unsigned int result;
74003
74004   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74005   argp2 = (Dali::Vector3 *)jarg2;
74006   if (!argp2) {
74007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74008     return 0;
74009   }
74010   arg2 = *argp2;
74011   {
74012     try {
74013       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
74014     } catch (std::out_of_range& e) {
74015       {
74016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74017       };
74018     } catch (std::exception& e) {
74019       {
74020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74021       };
74022     } catch (Dali::DaliException e) {
74023       {
74024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74025       };
74026     } catch (...) {
74027       {
74028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74029       };
74030     }
74031   }
74032
74033   jresult = result;
74034   return jresult;
74035 }
74036
74037
74038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74039   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74040   unsigned int arg2 ;
74041   Dali::Vector3 *arg3 = 0 ;
74042   Dali::Vector3 *arg4 = 0 ;
74043
74044   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74045   arg2 = (unsigned int)jarg2;
74046   arg3 = (Dali::Vector3 *)jarg3;
74047   if (!arg3) {
74048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74049     return ;
74050   }
74051   arg4 = (Dali::Vector3 *)jarg4;
74052   if (!arg4) {
74053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74054     return ;
74055   }
74056   {
74057     try {
74058       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74059     } catch (std::out_of_range& e) {
74060       {
74061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74062       };
74063     } catch (std::exception& e) {
74064       {
74065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74066       };
74067     } catch (Dali::DaliException e) {
74068       {
74069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74070       };
74071     } catch (...) {
74072       {
74073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74074       };
74075     }
74076   }
74077
74078 }
74079
74080
74081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74082   void * jresult ;
74083   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74084   Dali::Degree result;
74085
74086   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74087   {
74088     try {
74089       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74090     } catch (std::out_of_range& e) {
74091       {
74092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74093       };
74094     } catch (std::exception& e) {
74095       {
74096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74097       };
74098     } catch (Dali::DaliException e) {
74099       {
74100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74101       };
74102     } catch (...) {
74103       {
74104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74105       };
74106     }
74107   }
74108
74109   jresult = new Dali::Degree((const Dali::Degree &)result);
74110   return jresult;
74111 }
74112
74113
74114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74115   float jresult ;
74116   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74117   float result;
74118
74119   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74120   {
74121     try {
74122       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74123     } catch (std::out_of_range& e) {
74124       {
74125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74126       };
74127     } catch (std::exception& e) {
74128       {
74129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74130       };
74131     } catch (Dali::DaliException e) {
74132       {
74133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74134       };
74135     } catch (...) {
74136       {
74137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74138       };
74139     }
74140   }
74141
74142   jresult = result;
74143   return jresult;
74144 }
74145
74146
74147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
74148   float jresult ;
74149   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74150   float result;
74151
74152   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74153   {
74154     try {
74155       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
74156     } catch (std::out_of_range& e) {
74157       {
74158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74159       };
74160     } catch (std::exception& e) {
74161       {
74162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74163       };
74164     } catch (Dali::DaliException e) {
74165       {
74166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74167       };
74168     } catch (...) {
74169       {
74170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74171       };
74172     }
74173   }
74174
74175   jresult = result;
74176   return jresult;
74177 }
74178
74179
74180 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
74181   float jresult ;
74182   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74183   float result;
74184
74185   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74186   {
74187     try {
74188       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
74189     } catch (std::out_of_range& e) {
74190       {
74191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74192       };
74193     } catch (std::exception& e) {
74194       {
74195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74196       };
74197     } catch (Dali::DaliException e) {
74198       {
74199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74200       };
74201     } catch (...) {
74202       {
74203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74204       };
74205     }
74206   }
74207
74208   jresult = result;
74209   return jresult;
74210 }
74211
74212
74213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
74214   int jresult ;
74215   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74216   int arg2 ;
74217   int arg3 ;
74218   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
74219   bool arg5 ;
74220   int result;
74221
74222   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74223   arg2 = (int)jarg2;
74224   arg3 = (int)jarg3;
74225   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
74226   arg5 = jarg5 ? true : false;
74227   {
74228     try {
74229       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
74230     } catch (std::out_of_range& e) {
74231       {
74232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74233       };
74234     } catch (std::exception& e) {
74235       {
74236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74237       };
74238     } catch (Dali::DaliException e) {
74239       {
74240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74241       };
74242     } catch (...) {
74243       {
74244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74245       };
74246     }
74247   }
74248
74249   jresult = result;
74250   return jresult;
74251 }
74252
74253
74254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
74255   float jresult ;
74256   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74257   float result;
74258
74259   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74260   {
74261     try {
74262       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
74263     } catch (std::out_of_range& e) {
74264       {
74265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74266       };
74267     } catch (std::exception& e) {
74268       {
74269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74270       };
74271     } catch (Dali::DaliException e) {
74272       {
74273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74274       };
74275     } catch (...) {
74276       {
74277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74278       };
74279     }
74280   }
74281
74282   jresult = result;
74283   return jresult;
74284 }
74285
74286
74287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
74288   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74289   Dali::Actor *arg2 = 0 ;
74290   int arg3 ;
74291   Dali::Vector3 *arg4 = 0 ;
74292   Dali::Actor *arg5 = 0 ;
74293
74294   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74295   arg2 = (Dali::Actor *)jarg2;
74296   if (!arg2) {
74297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74298     return ;
74299   }
74300   arg3 = (int)jarg3;
74301   arg4 = (Dali::Vector3 *)jarg4;
74302   if (!arg4) {
74303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74304     return ;
74305   }
74306   arg5 = (Dali::Actor *)jarg5;
74307   if (!arg5) {
74308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
74309     return ;
74310   }
74311   {
74312     try {
74313       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
74314     } catch (std::out_of_range& e) {
74315       {
74316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74317       };
74318     } catch (std::exception& e) {
74319       {
74320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74321       };
74322     } catch (Dali::DaliException e) {
74323       {
74324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74325       };
74326     } catch (...) {
74327       {
74328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74329       };
74330     }
74331   }
74332
74333 }
74334
74335
74336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74337   void * jresult ;
74338   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74339   int arg2 ;
74340   float arg3 ;
74341   Dali::Vector3 *arg4 = 0 ;
74342   Dali::Vector3 result;
74343
74344   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74345   arg2 = (int)jarg2;
74346   arg3 = (float)jarg3;
74347   arg4 = (Dali::Vector3 *)jarg4;
74348   if (!arg4) {
74349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74350     return 0;
74351   }
74352   {
74353     try {
74354       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74355     } catch (std::out_of_range& e) {
74356       {
74357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74358       };
74359     } catch (std::exception& e) {
74360       {
74361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74362       };
74363     } catch (Dali::DaliException e) {
74364       {
74365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74366       };
74367     } catch (...) {
74368       {
74369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74370       };
74371     }
74372   }
74373
74374   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74375   return jresult;
74376 }
74377
74378
74379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
74380   void * jresult ;
74381   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
74382   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
74383
74384   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
74385   {
74386     try {
74387       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
74388     } catch (std::out_of_range& e) {
74389       {
74390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74391       };
74392     } catch (std::exception& e) {
74393       {
74394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74395       };
74396     } catch (Dali::DaliException e) {
74397       {
74398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74399       };
74400     } catch (...) {
74401       {
74402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74403       };
74404     }
74405   }
74406
74407   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
74408   return jresult;
74409 }
74410
74411
74412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
74413   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74414
74415   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74416   {
74417     try {
74418       delete arg1;
74419     } catch (std::out_of_range& e) {
74420       {
74421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74422       };
74423     } catch (std::exception& e) {
74424       {
74425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74426       };
74427     } catch (Dali::DaliException e) {
74428       {
74429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74430       };
74431     } catch (...) {
74432       {
74433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74434       };
74435     }
74436   }
74437
74438 }
74439
74440
74441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
74442   unsigned int jresult ;
74443   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74444   unsigned int result;
74445
74446   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74447   {
74448     try {
74449       result = (unsigned int)(arg1)->GetNumberOfItems();
74450     } catch (std::out_of_range& e) {
74451       {
74452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74453       };
74454     } catch (std::exception& e) {
74455       {
74456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74457       };
74458     } catch (Dali::DaliException e) {
74459       {
74460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74461       };
74462     } catch (...) {
74463       {
74464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74465       };
74466     }
74467   }
74468
74469   jresult = result;
74470   return jresult;
74471 }
74472
74473
74474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
74475   void * jresult ;
74476   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74477   unsigned int arg2 ;
74478   Dali::Actor result;
74479
74480   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74481   arg2 = (unsigned int)jarg2;
74482   {
74483     try {
74484       result = (arg1)->NewItem(arg2);
74485     } catch (std::out_of_range& e) {
74486       {
74487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74488       };
74489     } catch (std::exception& e) {
74490       {
74491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74492       };
74493     } catch (Dali::DaliException e) {
74494       {
74495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74496       };
74497     } catch (...) {
74498       {
74499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74500       };
74501     }
74502   }
74503
74504   jresult = new Dali::Actor((const Dali::Actor &)result);
74505   return jresult;
74506 }
74507
74508
74509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
74510   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74511   unsigned int arg2 ;
74512   Dali::Actor arg3 ;
74513   Dali::Actor *argp3 ;
74514
74515   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74516   arg2 = (unsigned int)jarg2;
74517   argp3 = (Dali::Actor *)jarg3;
74518   if (!argp3) {
74519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74520     return ;
74521   }
74522   arg3 = *argp3;
74523   {
74524     try {
74525       (arg1)->ItemReleased(arg2,arg3);
74526     } catch (std::out_of_range& e) {
74527       {
74528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74529       };
74530     } catch (std::exception& e) {
74531       {
74532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74533       };
74534     } catch (Dali::DaliException e) {
74535       {
74536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74537       };
74538     } catch (...) {
74539       {
74540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74541       };
74542     }
74543   }
74544
74545 }
74546
74547
74548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
74549   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74550   unsigned int arg2 ;
74551   Dali::Actor arg3 ;
74552   Dali::Actor *argp3 ;
74553
74554   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74555   arg2 = (unsigned int)jarg2;
74556   argp3 = (Dali::Actor *)jarg3;
74557   if (!argp3) {
74558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74559     return ;
74560   }
74561   arg3 = *argp3;
74562   {
74563     try {
74564       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
74565     } catch (std::out_of_range& e) {
74566       {
74567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74568       };
74569     } catch (std::exception& e) {
74570       {
74571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74572       };
74573     } catch (Dali::DaliException e) {
74574       {
74575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74576       };
74577     } catch (...) {
74578       {
74579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74580       };
74581     }
74582   }
74583
74584 }
74585
74586
74587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
74588   void * jresult ;
74589   Dali::Toolkit::ItemFactory *result = 0 ;
74590
74591   {
74592     try {
74593       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
74594     } catch (std::out_of_range& e) {
74595       {
74596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74597       };
74598     } catch (std::exception& e) {
74599       {
74600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74601       };
74602     } catch (Dali::DaliException e) {
74603       {
74604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74605       };
74606     } catch (...) {
74607       {
74608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74609       };
74610     }
74611   }
74612
74613   jresult = (void *)result;
74614   return jresult;
74615 }
74616
74617
74618 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) {
74619   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
74620   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
74621   if (director) {
74622     director->swig_connect_director(callback0, callback1, callback2);
74623   }
74624 }
74625
74626
74627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
74628   int jresult ;
74629   int result;
74630
74631   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
74632   jresult = (int)result;
74633   return jresult;
74634 }
74635
74636
74637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
74638   int jresult ;
74639   int result;
74640
74641   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
74642   jresult = (int)result;
74643   return jresult;
74644 }
74645
74646
74647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74648   int jresult ;
74649   int result;
74650
74651   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74652   jresult = (int)result;
74653   return jresult;
74654 }
74655
74656
74657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
74658   int jresult ;
74659   int result;
74660
74661   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
74662   jresult = (int)result;
74663   return jresult;
74664 }
74665
74666
74667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
74668   int jresult ;
74669   int result;
74670
74671   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
74672   jresult = (int)result;
74673   return jresult;
74674 }
74675
74676
74677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
74678   int jresult ;
74679   int result;
74680
74681   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
74682   jresult = (int)result;
74683   return jresult;
74684 }
74685
74686
74687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
74688   int jresult ;
74689   int result;
74690
74691   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
74692   jresult = (int)result;
74693   return jresult;
74694 }
74695
74696
74697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
74698   int jresult ;
74699   int result;
74700
74701   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
74702   jresult = (int)result;
74703   return jresult;
74704 }
74705
74706
74707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
74708   int jresult ;
74709   int result;
74710
74711   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
74712   jresult = (int)result;
74713   return jresult;
74714 }
74715
74716
74717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
74718   int jresult ;
74719   int result;
74720
74721   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
74722   jresult = (int)result;
74723   return jresult;
74724 }
74725
74726
74727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
74728   int jresult ;
74729   int result;
74730
74731   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
74732   jresult = (int)result;
74733   return jresult;
74734 }
74735
74736
74737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
74738   void * jresult ;
74739   Dali::Toolkit::ItemView::Property *result = 0 ;
74740
74741   {
74742     try {
74743       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
74744     } catch (std::out_of_range& e) {
74745       {
74746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74747       };
74748     } catch (std::exception& e) {
74749       {
74750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74751       };
74752     } catch (Dali::DaliException e) {
74753       {
74754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74755       };
74756     } catch (...) {
74757       {
74758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74759       };
74760     }
74761   }
74762
74763   jresult = (void *)result;
74764   return jresult;
74765 }
74766
74767
74768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
74769   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
74770
74771   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
74772   {
74773     try {
74774       delete arg1;
74775     } catch (std::out_of_range& e) {
74776       {
74777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74778       };
74779     } catch (std::exception& e) {
74780       {
74781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74782       };
74783     } catch (Dali::DaliException e) {
74784       {
74785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74786       };
74787     } catch (...) {
74788       {
74789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74790       };
74791     }
74792   }
74793
74794 }
74795
74796
74797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
74798   void * jresult ;
74799   Dali::Toolkit::ItemView *result = 0 ;
74800
74801   {
74802     try {
74803       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
74804     } catch (std::out_of_range& e) {
74805       {
74806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74807       };
74808     } catch (std::exception& e) {
74809       {
74810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74811       };
74812     } catch (Dali::DaliException e) {
74813       {
74814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74815       };
74816     } catch (...) {
74817       {
74818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74819       };
74820     }
74821   }
74822
74823   jresult = (void *)result;
74824   return jresult;
74825 }
74826
74827
74828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
74829   void * jresult ;
74830   Dali::Toolkit::ItemView *arg1 = 0 ;
74831   Dali::Toolkit::ItemView *result = 0 ;
74832
74833   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74834   if (!arg1) {
74835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74836     return 0;
74837   }
74838   {
74839     try {
74840       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
74841     } catch (std::out_of_range& e) {
74842       {
74843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74844       };
74845     } catch (std::exception& e) {
74846       {
74847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74848       };
74849     } catch (Dali::DaliException e) {
74850       {
74851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74852       };
74853     } catch (...) {
74854       {
74855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74856       };
74857     }
74858   }
74859
74860   jresult = (void *)result;
74861   return jresult;
74862 }
74863
74864
74865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
74866   void * jresult ;
74867   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74868   Dali::Toolkit::ItemView *arg2 = 0 ;
74869   Dali::Toolkit::ItemView *result = 0 ;
74870
74871   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74872   arg2 = (Dali::Toolkit::ItemView *)jarg2;
74873   if (!arg2) {
74874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74875     return 0;
74876   }
74877   {
74878     try {
74879       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
74880     } catch (std::out_of_range& e) {
74881       {
74882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74883       };
74884     } catch (std::exception& e) {
74885       {
74886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74887       };
74888     } catch (Dali::DaliException e) {
74889       {
74890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74891       };
74892     } catch (...) {
74893       {
74894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74895       };
74896     }
74897   }
74898
74899   jresult = (void *)result;
74900   return jresult;
74901 }
74902
74903
74904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
74905   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74906
74907   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74908   {
74909     try {
74910       delete arg1;
74911     } catch (std::out_of_range& e) {
74912       {
74913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74914       };
74915     } catch (std::exception& e) {
74916       {
74917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74918       };
74919     } catch (Dali::DaliException e) {
74920       {
74921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74922       };
74923     } catch (...) {
74924       {
74925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74926       };
74927     }
74928   }
74929
74930 }
74931
74932
74933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
74934   void * jresult ;
74935   Dali::Toolkit::ItemFactory *arg1 = 0 ;
74936   Dali::Toolkit::ItemView result;
74937
74938   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74939   if (!arg1) {
74940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
74941     return 0;
74942   }
74943   {
74944     try {
74945       result = Dali::Toolkit::ItemView::New(*arg1);
74946     } catch (std::out_of_range& e) {
74947       {
74948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74949       };
74950     } catch (std::exception& e) {
74951       {
74952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74953       };
74954     } catch (Dali::DaliException e) {
74955       {
74956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74957       };
74958     } catch (...) {
74959       {
74960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74961       };
74962     }
74963   }
74964
74965   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74966   return jresult;
74967 }
74968
74969
74970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
74971   void * jresult ;
74972   Dali::BaseHandle arg1 ;
74973   Dali::BaseHandle *argp1 ;
74974   Dali::Toolkit::ItemView result;
74975
74976   argp1 = (Dali::BaseHandle *)jarg1;
74977   if (!argp1) {
74978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74979     return 0;
74980   }
74981   arg1 = *argp1;
74982   {
74983     try {
74984       result = Dali::Toolkit::ItemView::DownCast(arg1);
74985     } catch (std::out_of_range& e) {
74986       {
74987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74988       };
74989     } catch (std::exception& e) {
74990       {
74991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74992       };
74993     } catch (Dali::DaliException e) {
74994       {
74995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74996       };
74997     } catch (...) {
74998       {
74999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75000       };
75001     }
75002   }
75003
75004   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75005   return jresult;
75006 }
75007
75008
75009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
75010   unsigned int jresult ;
75011   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75012   unsigned int result;
75013
75014   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75015   {
75016     try {
75017       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
75018     } catch (std::out_of_range& e) {
75019       {
75020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75021       };
75022     } catch (std::exception& e) {
75023       {
75024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75025       };
75026     } catch (Dali::DaliException e) {
75027       {
75028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75029       };
75030     } catch (...) {
75031       {
75032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75033       };
75034     }
75035   }
75036
75037   jresult = result;
75038   return jresult;
75039 }
75040
75041
75042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
75043   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75044   Dali::Toolkit::ItemLayout *arg2 = 0 ;
75045
75046   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75047   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
75048   if (!arg2) {
75049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
75050     return ;
75051   }
75052   {
75053     try {
75054       (arg1)->AddLayout(*arg2);
75055     } catch (std::out_of_range& e) {
75056       {
75057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75058       };
75059     } catch (std::exception& e) {
75060       {
75061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75062       };
75063     } catch (Dali::DaliException e) {
75064       {
75065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75066       };
75067     } catch (...) {
75068       {
75069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75070       };
75071     }
75072   }
75073
75074 }
75075
75076
75077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75078   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75079   unsigned int arg2 ;
75080
75081   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75082   arg2 = (unsigned int)jarg2;
75083   {
75084     try {
75085       (arg1)->RemoveLayout(arg2);
75086     } catch (std::out_of_range& e) {
75087       {
75088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75089       };
75090     } catch (std::exception& e) {
75091       {
75092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75093       };
75094     } catch (Dali::DaliException e) {
75095       {
75096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75097       };
75098     } catch (...) {
75099       {
75100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75101       };
75102     }
75103   }
75104
75105 }
75106
75107
75108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75109   void * jresult ;
75110   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75111   unsigned int arg2 ;
75112   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75113
75114   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75115   arg2 = (unsigned int)jarg2;
75116   {
75117     try {
75118       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75119     } catch (std::out_of_range& e) {
75120       {
75121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75122       };
75123     } catch (std::exception& e) {
75124       {
75125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75126       };
75127     } catch (Dali::DaliException e) {
75128       {
75129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75130       };
75131     } catch (...) {
75132       {
75133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75134       };
75135     }
75136   }
75137
75138   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75139   return jresult;
75140 }
75141
75142
75143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75144   void * jresult ;
75145   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75146   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75147
75148   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75149   {
75150     try {
75151       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
75152     } catch (std::out_of_range& e) {
75153       {
75154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75155       };
75156     } catch (std::exception& e) {
75157       {
75158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75159       };
75160     } catch (Dali::DaliException e) {
75161       {
75162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75163       };
75164     } catch (...) {
75165       {
75166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75167       };
75168     }
75169   }
75170
75171   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75172   return jresult;
75173 }
75174
75175
75176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
75177   float jresult ;
75178   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75179   Dali::Toolkit::ItemId arg2 ;
75180   float result;
75181
75182   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75183   arg2 = (Dali::Toolkit::ItemId)jarg2;
75184   {
75185     try {
75186       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
75187     } catch (std::out_of_range& e) {
75188       {
75189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75190       };
75191     } catch (std::exception& e) {
75192       {
75193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75194       };
75195     } catch (Dali::DaliException e) {
75196       {
75197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75198       };
75199     } catch (...) {
75200       {
75201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75202       };
75203     }
75204   }
75205
75206   jresult = result;
75207   return jresult;
75208 }
75209
75210
75211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
75212   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75213   unsigned int arg2 ;
75214   Dali::Vector3 arg3 ;
75215   float arg4 ;
75216   Dali::Vector3 *argp3 ;
75217
75218   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75219   arg2 = (unsigned int)jarg2;
75220   argp3 = (Dali::Vector3 *)jarg3;
75221   if (!argp3) {
75222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75223     return ;
75224   }
75225   arg3 = *argp3;
75226   arg4 = (float)jarg4;
75227   {
75228     try {
75229       (arg1)->ActivateLayout(arg2,arg3,arg4);
75230     } catch (std::out_of_range& e) {
75231       {
75232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75233       };
75234     } catch (std::exception& e) {
75235       {
75236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75237       };
75238     } catch (Dali::DaliException e) {
75239       {
75240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75241       };
75242     } catch (...) {
75243       {
75244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75245       };
75246     }
75247   }
75248
75249 }
75250
75251
75252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
75253   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75254
75255   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75256   {
75257     try {
75258       (arg1)->DeactivateCurrentLayout();
75259     } catch (std::out_of_range& e) {
75260       {
75261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75262       };
75263     } catch (std::exception& e) {
75264       {
75265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75266       };
75267     } catch (Dali::DaliException e) {
75268       {
75269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75270       };
75271     } catch (...) {
75272       {
75273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75274       };
75275     }
75276   }
75277
75278 }
75279
75280
75281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
75282   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75283   float arg2 ;
75284
75285   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75286   arg2 = (float)jarg2;
75287   {
75288     try {
75289       (arg1)->SetMinimumSwipeSpeed(arg2);
75290     } catch (std::out_of_range& e) {
75291       {
75292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75293       };
75294     } catch (std::exception& e) {
75295       {
75296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75297       };
75298     } catch (Dali::DaliException e) {
75299       {
75300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75301       };
75302     } catch (...) {
75303       {
75304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75305       };
75306     }
75307   }
75308
75309 }
75310
75311
75312 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
75313   float jresult ;
75314   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75315   float result;
75316
75317   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75318   {
75319     try {
75320       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
75321     } catch (std::out_of_range& e) {
75322       {
75323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75324       };
75325     } catch (std::exception& e) {
75326       {
75327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75328       };
75329     } catch (Dali::DaliException e) {
75330       {
75331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75332       };
75333     } catch (...) {
75334       {
75335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75336       };
75337     }
75338   }
75339
75340   jresult = result;
75341   return jresult;
75342 }
75343
75344
75345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
75346   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75347   float arg2 ;
75348
75349   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75350   arg2 = (float)jarg2;
75351   {
75352     try {
75353       (arg1)->SetMinimumSwipeDistance(arg2);
75354     } catch (std::out_of_range& e) {
75355       {
75356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75357       };
75358     } catch (std::exception& e) {
75359       {
75360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75361       };
75362     } catch (Dali::DaliException e) {
75363       {
75364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75365       };
75366     } catch (...) {
75367       {
75368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75369       };
75370     }
75371   }
75372
75373 }
75374
75375
75376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
75377   float jresult ;
75378   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75379   float result;
75380
75381   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75382   {
75383     try {
75384       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
75385     } catch (std::out_of_range& e) {
75386       {
75387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75388       };
75389     } catch (std::exception& e) {
75390       {
75391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75392       };
75393     } catch (Dali::DaliException e) {
75394       {
75395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75396       };
75397     } catch (...) {
75398       {
75399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75400       };
75401     }
75402   }
75403
75404   jresult = result;
75405   return jresult;
75406 }
75407
75408
75409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
75410   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75411   float arg2 ;
75412
75413   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75414   arg2 = (float)jarg2;
75415   {
75416     try {
75417       (arg1)->SetWheelScrollDistanceStep(arg2);
75418     } catch (std::out_of_range& e) {
75419       {
75420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75421       };
75422     } catch (std::exception& e) {
75423       {
75424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75425       };
75426     } catch (Dali::DaliException e) {
75427       {
75428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75429       };
75430     } catch (...) {
75431       {
75432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75433       };
75434     }
75435   }
75436
75437 }
75438
75439
75440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
75441   float jresult ;
75442   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75443   float result;
75444
75445   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75446   {
75447     try {
75448       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
75449     } catch (std::out_of_range& e) {
75450       {
75451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75452       };
75453     } catch (std::exception& e) {
75454       {
75455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75456       };
75457     } catch (Dali::DaliException e) {
75458       {
75459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75460       };
75461     } catch (...) {
75462       {
75463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75464       };
75465     }
75466   }
75467
75468   jresult = result;
75469   return jresult;
75470 }
75471
75472
75473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
75474   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75475   bool arg2 ;
75476
75477   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75478   arg2 = jarg2 ? true : false;
75479   {
75480     try {
75481       (arg1)->SetAnchoring(arg2);
75482     } catch (std::out_of_range& e) {
75483       {
75484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75485       };
75486     } catch (std::exception& e) {
75487       {
75488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75489       };
75490     } catch (Dali::DaliException e) {
75491       {
75492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75493       };
75494     } catch (...) {
75495       {
75496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75497       };
75498     }
75499   }
75500
75501 }
75502
75503 //// ========================= end of part 3 =============================
75504
75505 //// ========================== start part 4 ===============================
75506
75507
75508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
75509   unsigned int jresult ;
75510   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75511   bool result;
75512
75513   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75514   {
75515     try {
75516       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
75517     } catch (std::out_of_range& e) {
75518       {
75519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75520       };
75521     } catch (std::exception& e) {
75522       {
75523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75524       };
75525     } catch (Dali::DaliException e) {
75526       {
75527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75528       };
75529     } catch (...) {
75530       {
75531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75532       };
75533     }
75534   }
75535
75536   jresult = result;
75537   return jresult;
75538 }
75539
75540
75541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
75542   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75543   float arg2 ;
75544
75545   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75546   arg2 = (float)jarg2;
75547   {
75548     try {
75549       (arg1)->SetAnchoringDuration(arg2);
75550     } catch (std::out_of_range& e) {
75551       {
75552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75553       };
75554     } catch (std::exception& e) {
75555       {
75556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75557       };
75558     } catch (Dali::DaliException e) {
75559       {
75560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75561       };
75562     } catch (...) {
75563       {
75564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75565       };
75566     }
75567   }
75568
75569 }
75570
75571
75572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
75573   float jresult ;
75574   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75575   float result;
75576
75577   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75578   {
75579     try {
75580       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
75581     } catch (std::out_of_range& e) {
75582       {
75583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75584       };
75585     } catch (std::exception& e) {
75586       {
75587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75588       };
75589     } catch (Dali::DaliException e) {
75590       {
75591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75592       };
75593     } catch (...) {
75594       {
75595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75596       };
75597     }
75598   }
75599
75600   jresult = result;
75601   return jresult;
75602 }
75603
75604
75605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
75606   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75607   Dali::Toolkit::ItemId arg2 ;
75608   float arg3 ;
75609
75610   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75611   arg2 = (Dali::Toolkit::ItemId)jarg2;
75612   arg3 = (float)jarg3;
75613   {
75614     try {
75615       (arg1)->ScrollToItem(arg2,arg3);
75616     } catch (std::out_of_range& e) {
75617       {
75618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75619       };
75620     } catch (std::exception& e) {
75621       {
75622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75623       };
75624     } catch (Dali::DaliException e) {
75625       {
75626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75627       };
75628     } catch (...) {
75629       {
75630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75631       };
75632     }
75633   }
75634
75635 }
75636
75637
75638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
75639   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75640   float arg2 ;
75641
75642   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75643   arg2 = (float)jarg2;
75644   {
75645     try {
75646       (arg1)->SetRefreshInterval(arg2);
75647     } catch (std::out_of_range& e) {
75648       {
75649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75650       };
75651     } catch (std::exception& e) {
75652       {
75653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75654       };
75655     } catch (Dali::DaliException e) {
75656       {
75657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75658       };
75659     } catch (...) {
75660       {
75661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75662       };
75663     }
75664   }
75665
75666 }
75667
75668
75669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
75670   float jresult ;
75671   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75672   float result;
75673
75674   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75675   {
75676     try {
75677       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
75678     } catch (std::out_of_range& e) {
75679       {
75680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75681       };
75682     } catch (std::exception& e) {
75683       {
75684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75685       };
75686     } catch (Dali::DaliException e) {
75687       {
75688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75689       };
75690     } catch (...) {
75691       {
75692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75693       };
75694     }
75695   }
75696
75697   jresult = result;
75698   return jresult;
75699 }
75700
75701
75702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
75703   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75704
75705   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75706   {
75707     try {
75708       (arg1)->Refresh();
75709     } catch (std::out_of_range& e) {
75710       {
75711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75712       };
75713     } catch (std::exception& e) {
75714       {
75715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75716       };
75717     } catch (Dali::DaliException e) {
75718       {
75719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75720       };
75721     } catch (...) {
75722       {
75723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75724       };
75725     }
75726   }
75727
75728 }
75729
75730
75731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
75732   void * jresult ;
75733   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75734   Dali::Toolkit::ItemId arg2 ;
75735   Dali::Actor result;
75736
75737   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75738   arg2 = (Dali::Toolkit::ItemId)jarg2;
75739   {
75740     try {
75741       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
75742     } catch (std::out_of_range& e) {
75743       {
75744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75745       };
75746     } catch (std::exception& e) {
75747       {
75748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75749       };
75750     } catch (Dali::DaliException e) {
75751       {
75752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75753       };
75754     } catch (...) {
75755       {
75756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75757       };
75758     }
75759   }
75760
75761   jresult = new Dali::Actor((const Dali::Actor &)result);
75762   return jresult;
75763 }
75764
75765
75766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
75767   unsigned int jresult ;
75768   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75769   Dali::Actor arg2 ;
75770   Dali::Actor *argp2 ;
75771   Dali::Toolkit::ItemId result;
75772
75773   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75774   argp2 = (Dali::Actor *)jarg2;
75775   if (!argp2) {
75776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75777     return 0;
75778   }
75779   arg2 = *argp2;
75780   {
75781     try {
75782       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
75783     } catch (std::out_of_range& e) {
75784       {
75785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75786       };
75787     } catch (std::exception& e) {
75788       {
75789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75790       };
75791     } catch (Dali::DaliException e) {
75792       {
75793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75794       };
75795     } catch (...) {
75796       {
75797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75798       };
75799     }
75800   }
75801
75802   jresult = result;
75803   return jresult;
75804 }
75805
75806
75807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
75808   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75809   Dali::Toolkit::Item arg2 ;
75810   float arg3 ;
75811   Dali::Toolkit::Item *argp2 ;
75812
75813   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75814   argp2 = (Dali::Toolkit::Item *)jarg2;
75815   if (!argp2) {
75816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75817     return ;
75818   }
75819   arg2 = *argp2;
75820   arg3 = (float)jarg3;
75821   {
75822     try {
75823       (arg1)->InsertItem(arg2,arg3);
75824     } catch (std::out_of_range& e) {
75825       {
75826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75827       };
75828     } catch (std::exception& e) {
75829       {
75830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75831       };
75832     } catch (Dali::DaliException e) {
75833       {
75834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75835       };
75836     } catch (...) {
75837       {
75838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75839       };
75840     }
75841   }
75842
75843 }
75844
75845
75846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
75847   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75848   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75849   float arg3 ;
75850
75851   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75852   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75853   if (!arg2) {
75854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75855     return ;
75856   }
75857   arg3 = (float)jarg3;
75858   {
75859     try {
75860       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75861     } catch (std::out_of_range& e) {
75862       {
75863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75864       };
75865     } catch (std::exception& e) {
75866       {
75867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75868       };
75869     } catch (Dali::DaliException e) {
75870       {
75871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75872       };
75873     } catch (...) {
75874       {
75875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75876       };
75877     }
75878   }
75879
75880 }
75881
75882
75883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
75884   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75885   Dali::Toolkit::ItemId arg2 ;
75886   float arg3 ;
75887
75888   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75889   arg2 = (Dali::Toolkit::ItemId)jarg2;
75890   arg3 = (float)jarg3;
75891   {
75892     try {
75893       (arg1)->RemoveItem(arg2,arg3);
75894     } catch (std::out_of_range& e) {
75895       {
75896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75897       };
75898     } catch (std::exception& e) {
75899       {
75900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75901       };
75902     } catch (Dali::DaliException e) {
75903       {
75904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75905       };
75906     } catch (...) {
75907       {
75908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75909       };
75910     }
75911   }
75912
75913 }
75914
75915
75916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
75917   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75918   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
75919   float arg3 ;
75920
75921   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75922   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
75923   if (!arg2) {
75924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
75925     return ;
75926   }
75927   arg3 = (float)jarg3;
75928   {
75929     try {
75930       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
75931     } catch (std::out_of_range& e) {
75932       {
75933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75934       };
75935     } catch (std::exception& e) {
75936       {
75937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75938       };
75939     } catch (Dali::DaliException e) {
75940       {
75941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75942       };
75943     } catch (...) {
75944       {
75945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75946       };
75947     }
75948   }
75949
75950 }
75951
75952
75953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
75954   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75955   Dali::Toolkit::Item arg2 ;
75956   float arg3 ;
75957   Dali::Toolkit::Item *argp2 ;
75958
75959   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75960   argp2 = (Dali::Toolkit::Item *)jarg2;
75961   if (!argp2) {
75962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75963     return ;
75964   }
75965   arg2 = *argp2;
75966   arg3 = (float)jarg3;
75967   {
75968     try {
75969       (arg1)->ReplaceItem(arg2,arg3);
75970     } catch (std::out_of_range& e) {
75971       {
75972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75973       };
75974     } catch (std::exception& e) {
75975       {
75976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75977       };
75978     } catch (Dali::DaliException e) {
75979       {
75980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75981       };
75982     } catch (...) {
75983       {
75984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75985       };
75986     }
75987   }
75988
75989 }
75990
75991
75992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
75993   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75994   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75995   float arg3 ;
75996
75997   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75998   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75999   if (!arg2) {
76000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76001     return ;
76002   }
76003   arg3 = (float)jarg3;
76004   {
76005     try {
76006       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76007     } catch (std::out_of_range& e) {
76008       {
76009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76010       };
76011     } catch (std::exception& e) {
76012       {
76013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76014       };
76015     } catch (Dali::DaliException e) {
76016       {
76017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76018       };
76019     } catch (...) {
76020       {
76021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76022       };
76023     }
76024   }
76025
76026 }
76027
76028
76029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
76030   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76031   Dali::Vector3 *arg2 = 0 ;
76032
76033   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76034   arg2 = (Dali::Vector3 *)jarg2;
76035   if (!arg2) {
76036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76037     return ;
76038   }
76039   {
76040     try {
76041       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
76042     } catch (std::out_of_range& e) {
76043       {
76044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76045       };
76046     } catch (std::exception& e) {
76047       {
76048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76049       };
76050     } catch (Dali::DaliException e) {
76051       {
76052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76053       };
76054     } catch (...) {
76055       {
76056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76057       };
76058     }
76059   }
76060
76061 }
76062
76063
76064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
76065   void * jresult ;
76066   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76067   Dali::Vector3 result;
76068
76069   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76070   {
76071     try {
76072       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
76073     } catch (std::out_of_range& e) {
76074       {
76075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76076       };
76077     } catch (std::exception& e) {
76078       {
76079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76080       };
76081     } catch (Dali::DaliException e) {
76082       {
76083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76084       };
76085     } catch (...) {
76086       {
76087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76088       };
76089     }
76090   }
76091
76092   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76093   return jresult;
76094 }
76095
76096
76097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76098   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76099   Dali::Vector3 *arg2 = 0 ;
76100
76101   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76102   arg2 = (Dali::Vector3 *)jarg2;
76103   if (!arg2) {
76104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76105     return ;
76106   }
76107   {
76108     try {
76109       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76110     } catch (std::out_of_range& e) {
76111       {
76112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76113       };
76114     } catch (std::exception& e) {
76115       {
76116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76117       };
76118     } catch (Dali::DaliException e) {
76119       {
76120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76121       };
76122     } catch (...) {
76123       {
76124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76125       };
76126     }
76127   }
76128
76129 }
76130
76131
76132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76133   void * jresult ;
76134   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76135   Dali::Vector3 result;
76136
76137   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76138   {
76139     try {
76140       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76141     } catch (std::out_of_range& e) {
76142       {
76143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76144       };
76145     } catch (std::exception& e) {
76146       {
76147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76148       };
76149     } catch (Dali::DaliException e) {
76150       {
76151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76152       };
76153     } catch (...) {
76154       {
76155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76156       };
76157     }
76158   }
76159
76160   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76161   return jresult;
76162 }
76163
76164
76165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
76166   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76167   Dali::Toolkit::ItemRange *arg2 = 0 ;
76168
76169   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76170   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
76171   if (!arg2) {
76172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
76173     return ;
76174   }
76175   {
76176     try {
76177       (arg1)->GetItemsRange(*arg2);
76178     } catch (std::out_of_range& e) {
76179       {
76180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76181       };
76182     } catch (std::exception& e) {
76183       {
76184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76185       };
76186     } catch (Dali::DaliException e) {
76187       {
76188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76189       };
76190     } catch (...) {
76191       {
76192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76193       };
76194     }
76195   }
76196
76197 }
76198
76199
76200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
76201   void * jresult ;
76202   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76203   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
76204
76205   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76206   {
76207     try {
76208       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
76209     } catch (std::out_of_range& e) {
76210       {
76211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76212       };
76213     } catch (std::exception& e) {
76214       {
76215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76216       };
76217     } catch (Dali::DaliException e) {
76218       {
76219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76220       };
76221     } catch (...) {
76222       {
76223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76224       };
76225     }
76226   }
76227
76228   jresult = (void *)result;
76229   return jresult;
76230 }
76231
76232
76233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
76234   Dali::Vector3 *arg1 = 0 ;
76235   PropertyInputContainer *arg2 = 0 ;
76236
76237   arg1 = (Dali::Vector3 *)jarg1;
76238   if (!arg1) {
76239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76240     return ;
76241   }
76242   arg2 = (PropertyInputContainer *)jarg2;
76243   if (!arg2) {
76244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76245     return ;
76246   }
76247   {
76248     try {
76249       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76250     } catch (std::out_of_range& e) {
76251       {
76252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76253       };
76254     } catch (std::exception& e) {
76255       {
76256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76257       };
76258     } catch (Dali::DaliException e) {
76259       {
76260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76261       };
76262     } catch (...) {
76263       {
76264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76265       };
76266     }
76267   }
76268
76269 }
76270
76271
76272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
76273   Dali::Vector3 *arg1 = 0 ;
76274   PropertyInputContainer *arg2 = 0 ;
76275
76276   arg1 = (Dali::Vector3 *)jarg1;
76277   if (!arg1) {
76278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76279     return ;
76280   }
76281   arg2 = (PropertyInputContainer *)jarg2;
76282   if (!arg2) {
76283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76284     return ;
76285   }
76286   {
76287     try {
76288       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76289     } catch (std::out_of_range& e) {
76290       {
76291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76292       };
76293     } catch (std::exception& e) {
76294       {
76295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76296       };
76297     } catch (Dali::DaliException e) {
76298       {
76299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76300       };
76301     } catch (...) {
76302       {
76303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76304       };
76305     }
76306   }
76307
76308 }
76309
76310
76311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
76312   void * jresult ;
76313   Dali::Toolkit::ScrollViewEffect *result = 0 ;
76314
76315   {
76316     try {
76317       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
76318     } catch (std::out_of_range& e) {
76319       {
76320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76321       };
76322     } catch (std::exception& e) {
76323       {
76324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76325       };
76326     } catch (Dali::DaliException e) {
76327       {
76328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76329       };
76330     } catch (...) {
76331       {
76332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76333       };
76334     }
76335   }
76336
76337   jresult = (void *)result;
76338   return jresult;
76339 }
76340
76341
76342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
76343   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
76344
76345   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
76346   {
76347     try {
76348       delete arg1;
76349     } catch (std::out_of_range& e) {
76350       {
76351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76352       };
76353     } catch (std::exception& e) {
76354       {
76355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76356       };
76357     } catch (Dali::DaliException e) {
76358       {
76359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76360       };
76361     } catch (...) {
76362       {
76363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76364       };
76365     }
76366   }
76367
76368 }
76369
76370
76371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
76372   void * jresult ;
76373   Dali::Path arg1 ;
76374   Dali::Vector3 *arg2 = 0 ;
76375   Dali::Property::Index arg3 ;
76376   Dali::Vector3 *arg4 = 0 ;
76377   unsigned int arg5 ;
76378   Dali::Path *argp1 ;
76379   Dali::Toolkit::ScrollViewPagePathEffect result;
76380
76381   argp1 = (Dali::Path *)jarg1;
76382   if (!argp1) {
76383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
76384     return 0;
76385   }
76386   arg1 = *argp1;
76387   arg2 = (Dali::Vector3 *)jarg2;
76388   if (!arg2) {
76389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76390     return 0;
76391   }
76392   arg3 = (Dali::Property::Index)jarg3;
76393   arg4 = (Dali::Vector3 *)jarg4;
76394   if (!arg4) {
76395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76396     return 0;
76397   }
76398   arg5 = (unsigned int)jarg5;
76399   {
76400     try {
76401       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
76402     } catch (std::out_of_range& e) {
76403       {
76404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76405       };
76406     } catch (std::exception& e) {
76407       {
76408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76409       };
76410     } catch (Dali::DaliException e) {
76411       {
76412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76413       };
76414     } catch (...) {
76415       {
76416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76417       };
76418     }
76419   }
76420
76421   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76422   return jresult;
76423 }
76424
76425
76426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
76427   void * jresult ;
76428   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
76429
76430   {
76431     try {
76432       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
76433     } catch (std::out_of_range& e) {
76434       {
76435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76436       };
76437     } catch (std::exception& e) {
76438       {
76439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76440       };
76441     } catch (Dali::DaliException e) {
76442       {
76443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76444       };
76445     } catch (...) {
76446       {
76447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76448       };
76449     }
76450   }
76451
76452   jresult = (void *)result;
76453   return jresult;
76454 }
76455
76456
76457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
76458   void * jresult ;
76459   Dali::BaseHandle arg1 ;
76460   Dali::BaseHandle *argp1 ;
76461   Dali::Toolkit::ScrollViewPagePathEffect result;
76462
76463   argp1 = (Dali::BaseHandle *)jarg1;
76464   if (!argp1) {
76465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76466     return 0;
76467   }
76468   arg1 = *argp1;
76469   {
76470     try {
76471       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
76472     } catch (std::out_of_range& e) {
76473       {
76474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76475       };
76476     } catch (std::exception& e) {
76477       {
76478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76479       };
76480     } catch (Dali::DaliException e) {
76481       {
76482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76483       };
76484     } catch (...) {
76485       {
76486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76487       };
76488     }
76489   }
76490
76491   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76492   return jresult;
76493 }
76494
76495
76496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
76497   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76498   Dali::Actor arg2 ;
76499   unsigned int arg3 ;
76500   Dali::Actor *argp2 ;
76501
76502   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76503   argp2 = (Dali::Actor *)jarg2;
76504   if (!argp2) {
76505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76506     return ;
76507   }
76508   arg2 = *argp2;
76509   arg3 = (unsigned int)jarg3;
76510   {
76511     try {
76512       (arg1)->ApplyToPage(arg2,arg3);
76513     } catch (std::out_of_range& e) {
76514       {
76515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76516       };
76517     } catch (std::exception& e) {
76518       {
76519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76520       };
76521     } catch (Dali::DaliException e) {
76522       {
76523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76524       };
76525     } catch (...) {
76526       {
76527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76528       };
76529     }
76530   }
76531
76532 }
76533
76534
76535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
76536   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76537
76538   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76539   {
76540     try {
76541       delete arg1;
76542     } catch (std::out_of_range& e) {
76543       {
76544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76545       };
76546     } catch (std::exception& e) {
76547       {
76548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76549       };
76550     } catch (Dali::DaliException e) {
76551       {
76552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76553       };
76554     } catch (...) {
76555       {
76556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76557       };
76558     }
76559   }
76560
76561 }
76562
76563
76564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
76565   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76566   Dali::Toolkit::ClampState arg2 ;
76567
76568   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76569   arg2 = (Dali::Toolkit::ClampState)jarg2;
76570   if (arg1) (arg1)->x = arg2;
76571 }
76572
76573
76574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
76575   int jresult ;
76576   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76577   Dali::Toolkit::ClampState result;
76578
76579   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76580   result = (Dali::Toolkit::ClampState) ((arg1)->x);
76581   jresult = (int)result;
76582   return jresult;
76583 }
76584
76585
76586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
76587   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76588   Dali::Toolkit::ClampState arg2 ;
76589
76590   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76591   arg2 = (Dali::Toolkit::ClampState)jarg2;
76592   if (arg1) (arg1)->y = arg2;
76593 }
76594
76595
76596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
76597   int jresult ;
76598   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76599   Dali::Toolkit::ClampState result;
76600
76601   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76602   result = (Dali::Toolkit::ClampState) ((arg1)->y);
76603   jresult = (int)result;
76604   return jresult;
76605 }
76606
76607
76608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
76609   void * jresult ;
76610   Dali::Toolkit::ClampState2D *result = 0 ;
76611
76612   {
76613     try {
76614       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
76615     } catch (std::out_of_range& e) {
76616       {
76617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76618       };
76619     } catch (std::exception& e) {
76620       {
76621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76622       };
76623     } catch (Dali::DaliException e) {
76624       {
76625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76626       };
76627     } catch (...) {
76628       {
76629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76630       };
76631     }
76632   }
76633
76634   jresult = (void *)result;
76635   return jresult;
76636 }
76637
76638
76639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
76640   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76641
76642   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76643   {
76644     try {
76645       delete arg1;
76646     } catch (std::out_of_range& e) {
76647       {
76648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76649       };
76650     } catch (std::exception& e) {
76651       {
76652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76653       };
76654     } catch (Dali::DaliException e) {
76655       {
76656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76657       };
76658     } catch (...) {
76659       {
76660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76661       };
76662     }
76663   }
76664
76665 }
76666
76667
76668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
76669   void * jresult ;
76670   float arg1 ;
76671   float arg2 ;
76672   bool arg3 ;
76673   Dali::Toolkit::RulerDomain *result = 0 ;
76674
76675   arg1 = (float)jarg1;
76676   arg2 = (float)jarg2;
76677   arg3 = jarg3 ? true : false;
76678   {
76679     try {
76680       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
76681     } catch (std::out_of_range& e) {
76682       {
76683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76684       };
76685     } catch (std::exception& e) {
76686       {
76687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76688       };
76689     } catch (Dali::DaliException e) {
76690       {
76691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76692       };
76693     } catch (...) {
76694       {
76695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76696       };
76697     }
76698   }
76699
76700   jresult = (void *)result;
76701   return jresult;
76702 }
76703
76704
76705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
76706   void * jresult ;
76707   float arg1 ;
76708   float arg2 ;
76709   Dali::Toolkit::RulerDomain *result = 0 ;
76710
76711   arg1 = (float)jarg1;
76712   arg2 = (float)jarg2;
76713   {
76714     try {
76715       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
76716     } catch (std::out_of_range& e) {
76717       {
76718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76719       };
76720     } catch (std::exception& e) {
76721       {
76722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76723       };
76724     } catch (Dali::DaliException e) {
76725       {
76726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76727       };
76728     } catch (...) {
76729       {
76730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76731       };
76732     }
76733   }
76734
76735   jresult = (void *)result;
76736   return jresult;
76737 }
76738
76739
76740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
76741   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76742   float arg2 ;
76743
76744   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76745   arg2 = (float)jarg2;
76746   if (arg1) (arg1)->min = arg2;
76747 }
76748
76749
76750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
76751   float jresult ;
76752   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76753   float result;
76754
76755   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76756   result = (float) ((arg1)->min);
76757   jresult = result;
76758   return jresult;
76759 }
76760
76761
76762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
76763   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76764   float arg2 ;
76765
76766   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76767   arg2 = (float)jarg2;
76768   if (arg1) (arg1)->max = arg2;
76769 }
76770
76771
76772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
76773   float jresult ;
76774   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76775   float result;
76776
76777   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76778   result = (float) ((arg1)->max);
76779   jresult = result;
76780   return jresult;
76781 }
76782
76783
76784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
76785   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76786   bool arg2 ;
76787
76788   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76789   arg2 = jarg2 ? true : false;
76790   if (arg1) (arg1)->enabled = arg2;
76791 }
76792
76793
76794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
76795   unsigned int jresult ;
76796   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76797   bool result;
76798
76799   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76800   result = (bool) ((arg1)->enabled);
76801   jresult = result;
76802   return jresult;
76803 }
76804
76805
76806 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
76807   float jresult ;
76808   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76809   float arg2 ;
76810   float arg3 ;
76811   float arg4 ;
76812   float result;
76813
76814   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76815   arg2 = (float)jarg2;
76816   arg3 = (float)jarg3;
76817   arg4 = (float)jarg4;
76818   {
76819     try {
76820       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
76821     } catch (std::out_of_range& e) {
76822       {
76823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76824       };
76825     } catch (std::exception& e) {
76826       {
76827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76828       };
76829     } catch (Dali::DaliException e) {
76830       {
76831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76832       };
76833     } catch (...) {
76834       {
76835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76836       };
76837     }
76838   }
76839
76840   jresult = result;
76841   return jresult;
76842 }
76843
76844
76845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
76846   float jresult ;
76847   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76848   float arg2 ;
76849   float arg3 ;
76850   float result;
76851
76852   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76853   arg2 = (float)jarg2;
76854   arg3 = (float)jarg3;
76855   {
76856     try {
76857       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
76858     } catch (std::out_of_range& e) {
76859       {
76860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76861       };
76862     } catch (std::exception& e) {
76863       {
76864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76865       };
76866     } catch (Dali::DaliException e) {
76867       {
76868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76869       };
76870     } catch (...) {
76871       {
76872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76873       };
76874     }
76875   }
76876
76877   jresult = result;
76878   return jresult;
76879 }
76880
76881
76882 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
76883   float jresult ;
76884   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76885   float arg2 ;
76886   float result;
76887
76888   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76889   arg2 = (float)jarg2;
76890   {
76891     try {
76892       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
76893     } catch (std::out_of_range& e) {
76894       {
76895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76896       };
76897     } catch (std::exception& e) {
76898       {
76899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76900       };
76901     } catch (Dali::DaliException e) {
76902       {
76903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76904       };
76905     } catch (...) {
76906       {
76907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76908       };
76909     }
76910   }
76911
76912   jresult = result;
76913   return jresult;
76914 }
76915
76916
76917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
76918   float jresult ;
76919   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76920   float arg2 ;
76921   float arg3 ;
76922   float arg4 ;
76923   Dali::Toolkit::ClampState *arg5 = 0 ;
76924   float result;
76925
76926   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76927   arg2 = (float)jarg2;
76928   arg3 = (float)jarg3;
76929   arg4 = (float)jarg4;
76930   arg5 = (Dali::Toolkit::ClampState *)jarg5;
76931   if (!arg5) {
76932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
76933     return 0;
76934   }
76935   {
76936     try {
76937       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
76938     } catch (std::out_of_range& e) {
76939       {
76940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76941       };
76942     } catch (std::exception& e) {
76943       {
76944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76945       };
76946     } catch (Dali::DaliException e) {
76947       {
76948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76949       };
76950     } catch (...) {
76951       {
76952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76953       };
76954     }
76955   }
76956
76957   jresult = result;
76958   return jresult;
76959 }
76960
76961
76962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
76963   float jresult ;
76964   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76965   float result;
76966
76967   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76968   {
76969     try {
76970       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
76971     } catch (std::out_of_range& e) {
76972       {
76973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76974       };
76975     } catch (std::exception& e) {
76976       {
76977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76978       };
76979     } catch (Dali::DaliException e) {
76980       {
76981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76982       };
76983     } catch (...) {
76984       {
76985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76986       };
76987     }
76988   }
76989
76990   jresult = result;
76991   return jresult;
76992 }
76993
76994
76995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
76996   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76997
76998   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76999   {
77000     try {
77001       delete arg1;
77002     } catch (std::out_of_range& e) {
77003       {
77004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77005       };
77006     } catch (std::exception& e) {
77007       {
77008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77009       };
77010     } catch (Dali::DaliException e) {
77011       {
77012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77013       };
77014     } catch (...) {
77015       {
77016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77017       };
77018     }
77019   }
77020
77021 }
77022
77023
77024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
77025   float jresult ;
77026   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77027   float arg2 ;
77028   float arg3 ;
77029   float result;
77030
77031   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77032   arg2 = (float)jarg2;
77033   arg3 = (float)jarg3;
77034   {
77035     try {
77036       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
77037     } catch (std::out_of_range& e) {
77038       {
77039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77040       };
77041     } catch (std::exception& e) {
77042       {
77043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77044       };
77045     } catch (Dali::DaliException e) {
77046       {
77047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77048       };
77049     } catch (...) {
77050       {
77051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77052       };
77053     }
77054   }
77055
77056   jresult = result;
77057   return jresult;
77058 }
77059
77060
77061 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
77062   float jresult ;
77063   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77064   float arg2 ;
77065   float result;
77066
77067   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77068   arg2 = (float)jarg2;
77069   {
77070     try {
77071       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
77072     } catch (std::out_of_range& e) {
77073       {
77074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77075       };
77076     } catch (std::exception& e) {
77077       {
77078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77079       };
77080     } catch (Dali::DaliException e) {
77081       {
77082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77083       };
77084     } catch (...) {
77085       {
77086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77087       };
77088     }
77089   }
77090
77091   jresult = result;
77092   return jresult;
77093 }
77094
77095
77096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77097   float jresult ;
77098   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77099   unsigned int arg2 ;
77100   unsigned int *arg3 = 0 ;
77101   bool arg4 ;
77102   float result;
77103
77104   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77105   arg2 = (unsigned int)jarg2;
77106   arg3 = (unsigned int *)jarg3;
77107   arg4 = jarg4 ? true : false;
77108   {
77109     try {
77110       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77111     } catch (std::out_of_range& e) {
77112       {
77113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77114       };
77115     } catch (std::exception& e) {
77116       {
77117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77118       };
77119     } catch (Dali::DaliException e) {
77120       {
77121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77122       };
77123     } catch (...) {
77124       {
77125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77126       };
77127     }
77128   }
77129
77130   jresult = result;
77131   return jresult;
77132 }
77133
77134
77135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77136   unsigned int jresult ;
77137   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77138   float arg2 ;
77139   bool arg3 ;
77140   unsigned int result;
77141
77142   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77143   arg2 = (float)jarg2;
77144   arg3 = jarg3 ? true : false;
77145   {
77146     try {
77147       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
77148     } catch (std::out_of_range& e) {
77149       {
77150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77151       };
77152     } catch (std::exception& e) {
77153       {
77154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77155       };
77156     } catch (Dali::DaliException e) {
77157       {
77158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77159       };
77160     } catch (...) {
77161       {
77162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77163       };
77164     }
77165   }
77166
77167   jresult = result;
77168   return jresult;
77169 }
77170
77171
77172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
77173   unsigned int jresult ;
77174   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77175   unsigned int result;
77176
77177   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77178   {
77179     try {
77180       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
77181     } catch (std::out_of_range& e) {
77182       {
77183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77184       };
77185     } catch (std::exception& e) {
77186       {
77187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77188       };
77189     } catch (Dali::DaliException e) {
77190       {
77191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77192       };
77193     } catch (...) {
77194       {
77195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77196       };
77197     }
77198   }
77199
77200   jresult = result;
77201   return jresult;
77202 }
77203
77204
77205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
77206   int jresult ;
77207   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77208   Dali::Toolkit::Ruler::RulerType result;
77209
77210   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77211   {
77212     try {
77213       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
77214     } catch (std::out_of_range& e) {
77215       {
77216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77217       };
77218     } catch (std::exception& e) {
77219       {
77220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77221       };
77222     } catch (Dali::DaliException e) {
77223       {
77224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77225       };
77226     } catch (...) {
77227       {
77228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77229       };
77230     }
77231   }
77232
77233   jresult = (int)result;
77234   return jresult;
77235 }
77236
77237
77238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
77239   unsigned int jresult ;
77240   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77241   bool result;
77242
77243   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77244   {
77245     try {
77246       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
77247     } catch (std::out_of_range& e) {
77248       {
77249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77250       };
77251     } catch (std::exception& e) {
77252       {
77253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77254       };
77255     } catch (Dali::DaliException e) {
77256       {
77257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77258       };
77259     } catch (...) {
77260       {
77261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77262       };
77263     }
77264   }
77265
77266   jresult = result;
77267   return jresult;
77268 }
77269
77270
77271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
77272   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77273
77274   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77275   {
77276     try {
77277       (arg1)->Enable();
77278     } catch (std::out_of_range& e) {
77279       {
77280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77281       };
77282     } catch (std::exception& e) {
77283       {
77284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77285       };
77286     } catch (Dali::DaliException e) {
77287       {
77288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77289       };
77290     } catch (...) {
77291       {
77292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77293       };
77294     }
77295   }
77296
77297 }
77298
77299
77300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
77301   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77302
77303   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77304   {
77305     try {
77306       (arg1)->Disable();
77307     } catch (std::out_of_range& e) {
77308       {
77309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77310       };
77311     } catch (std::exception& e) {
77312       {
77313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77314       };
77315     } catch (Dali::DaliException e) {
77316       {
77317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77318       };
77319     } catch (...) {
77320       {
77321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77322       };
77323     }
77324   }
77325
77326 }
77327
77328
77329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
77330   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77331   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
77332   Dali::Toolkit::RulerDomain *argp2 ;
77333
77334   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77335   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
77336   if (!argp2) {
77337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
77338     return ;
77339   }
77340   arg2 = *argp2;
77341   {
77342     try {
77343       (arg1)->SetDomain(arg2);
77344     } catch (std::out_of_range& e) {
77345       {
77346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77347       };
77348     } catch (std::exception& e) {
77349       {
77350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77351       };
77352     } catch (Dali::DaliException e) {
77353       {
77354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77355       };
77356     } catch (...) {
77357       {
77358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77359       };
77360     }
77361   }
77362
77363 }
77364
77365
77366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
77367   void * jresult ;
77368   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77369   Dali::Toolkit::RulerDomain *result = 0 ;
77370
77371   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77372   {
77373     try {
77374       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
77375     } catch (std::out_of_range& e) {
77376       {
77377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77378       };
77379     } catch (std::exception& e) {
77380       {
77381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77382       };
77383     } catch (Dali::DaliException e) {
77384       {
77385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77386       };
77387     } catch (...) {
77388       {
77389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77390       };
77391     }
77392   }
77393
77394   jresult = (void *)result;
77395   return jresult;
77396 }
77397
77398
77399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
77400   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77401
77402   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77403   {
77404     try {
77405       (arg1)->DisableDomain();
77406     } catch (std::out_of_range& e) {
77407       {
77408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77409       };
77410     } catch (std::exception& e) {
77411       {
77412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77413       };
77414     } catch (Dali::DaliException e) {
77415       {
77416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77417       };
77418     } catch (...) {
77419       {
77420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77421       };
77422     }
77423   }
77424
77425 }
77426
77427
77428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77429   float jresult ;
77430   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77431   float arg2 ;
77432   float arg3 ;
77433   float arg4 ;
77434   float result;
77435
77436   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77437   arg2 = (float)jarg2;
77438   arg3 = (float)jarg3;
77439   arg4 = (float)jarg4;
77440   {
77441     try {
77442       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
77443     } catch (std::out_of_range& e) {
77444       {
77445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77446       };
77447     } catch (std::exception& e) {
77448       {
77449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77450       };
77451     } catch (Dali::DaliException e) {
77452       {
77453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77454       };
77455     } catch (...) {
77456       {
77457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77458       };
77459     }
77460   }
77461
77462   jresult = result;
77463   return jresult;
77464 }
77465
77466
77467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77468   float jresult ;
77469   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77470   float arg2 ;
77471   float arg3 ;
77472   float result;
77473
77474   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77475   arg2 = (float)jarg2;
77476   arg3 = (float)jarg3;
77477   {
77478     try {
77479       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
77480     } catch (std::out_of_range& e) {
77481       {
77482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77483       };
77484     } catch (std::exception& e) {
77485       {
77486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77487       };
77488     } catch (Dali::DaliException e) {
77489       {
77490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77491       };
77492     } catch (...) {
77493       {
77494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77495       };
77496     }
77497   }
77498
77499   jresult = result;
77500   return jresult;
77501 }
77502
77503
77504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
77505   float jresult ;
77506   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77507   float arg2 ;
77508   float result;
77509
77510   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77511   arg2 = (float)jarg2;
77512   {
77513     try {
77514       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
77515     } catch (std::out_of_range& e) {
77516       {
77517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77518       };
77519     } catch (std::exception& e) {
77520       {
77521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77522       };
77523     } catch (Dali::DaliException e) {
77524       {
77525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77526       };
77527     } catch (...) {
77528       {
77529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77530       };
77531     }
77532   }
77533
77534   jresult = result;
77535   return jresult;
77536 }
77537
77538
77539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77540   float jresult ;
77541   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77542   float arg2 ;
77543   float arg3 ;
77544   float arg4 ;
77545   Dali::Toolkit::ClampState *arg5 = 0 ;
77546   float result;
77547
77548   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77549   arg2 = (float)jarg2;
77550   arg3 = (float)jarg3;
77551   arg4 = (float)jarg4;
77552   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77553   if (!arg5) {
77554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77555     return 0;
77556   }
77557   {
77558     try {
77559       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77560     } catch (std::out_of_range& e) {
77561       {
77562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77563       };
77564     } catch (std::exception& e) {
77565       {
77566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77567       };
77568     } catch (Dali::DaliException e) {
77569       {
77570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77571       };
77572     } catch (...) {
77573       {
77574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77575       };
77576     }
77577   }
77578
77579   jresult = result;
77580   return jresult;
77581 }
77582
77583
77584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
77585   float jresult ;
77586   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77587   float arg2 ;
77588   float arg3 ;
77589   float arg4 ;
77590   float arg5 ;
77591   float result;
77592
77593   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77594   arg2 = (float)jarg2;
77595   arg3 = (float)jarg3;
77596   arg4 = (float)jarg4;
77597   arg5 = (float)jarg5;
77598   {
77599     try {
77600       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
77601     } catch (std::out_of_range& e) {
77602       {
77603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77604       };
77605     } catch (std::exception& e) {
77606       {
77607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77608       };
77609     } catch (Dali::DaliException e) {
77610       {
77611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77612       };
77613     } catch (...) {
77614       {
77615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77616       };
77617     }
77618   }
77619
77620   jresult = result;
77621   return jresult;
77622 }
77623
77624
77625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
77626   float jresult ;
77627   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77628   float arg2 ;
77629   float arg3 ;
77630   float arg4 ;
77631   float result;
77632
77633   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77634   arg2 = (float)jarg2;
77635   arg3 = (float)jarg3;
77636   arg4 = (float)jarg4;
77637   {
77638     try {
77639       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
77640     } catch (std::out_of_range& e) {
77641       {
77642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77643       };
77644     } catch (std::exception& e) {
77645       {
77646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77647       };
77648     } catch (Dali::DaliException e) {
77649       {
77650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77651       };
77652     } catch (...) {
77653       {
77654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77655       };
77656     }
77657   }
77658
77659   jresult = result;
77660   return jresult;
77661 }
77662
77663
77664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
77665   float jresult ;
77666   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77667   float arg2 ;
77668   float arg3 ;
77669   float result;
77670
77671   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77672   arg2 = (float)jarg2;
77673   arg3 = (float)jarg3;
77674   {
77675     try {
77676       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
77677     } catch (std::out_of_range& e) {
77678       {
77679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77680       };
77681     } catch (std::exception& e) {
77682       {
77683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77684       };
77685     } catch (Dali::DaliException e) {
77686       {
77687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77688       };
77689     } catch (...) {
77690       {
77691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77692       };
77693     }
77694   }
77695
77696   jresult = result;
77697   return jresult;
77698 }
77699
77700
77701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
77702   float jresult ;
77703   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77704   float arg2 ;
77705   float result;
77706
77707   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77708   arg2 = (float)jarg2;
77709   {
77710     try {
77711       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
77712     } catch (std::out_of_range& e) {
77713       {
77714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77715       };
77716     } catch (std::exception& e) {
77717       {
77718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77719       };
77720     } catch (Dali::DaliException e) {
77721       {
77722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77723       };
77724     } catch (...) {
77725       {
77726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77727       };
77728     }
77729   }
77730
77731   jresult = result;
77732   return jresult;
77733 }
77734
77735
77736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
77737   float jresult ;
77738   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77739   float arg2 ;
77740   float arg3 ;
77741   float arg4 ;
77742   float arg5 ;
77743   Dali::Toolkit::ClampState *arg6 = 0 ;
77744   float result;
77745
77746   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77747   arg2 = (float)jarg2;
77748   arg3 = (float)jarg3;
77749   arg4 = (float)jarg4;
77750   arg5 = (float)jarg5;
77751   arg6 = (Dali::Toolkit::ClampState *)jarg6;
77752   if (!arg6) {
77753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77754     return 0;
77755   }
77756   {
77757     try {
77758       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
77759     } catch (std::out_of_range& e) {
77760       {
77761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77762       };
77763     } catch (std::exception& e) {
77764       {
77765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77766       };
77767     } catch (Dali::DaliException e) {
77768       {
77769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77770       };
77771     } catch (...) {
77772       {
77773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77774       };
77775     }
77776   }
77777
77778   jresult = result;
77779   return jresult;
77780 }
77781
77782
77783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
77784   void * jresult ;
77785   Dali::Toolkit::DefaultRuler *result = 0 ;
77786
77787   {
77788     try {
77789       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
77790     } catch (std::out_of_range& e) {
77791       {
77792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77793       };
77794     } catch (std::exception& e) {
77795       {
77796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77797       };
77798     } catch (Dali::DaliException e) {
77799       {
77800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77801       };
77802     } catch (...) {
77803       {
77804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77805       };
77806     }
77807   }
77808
77809   jresult = (void *)result;
77810   return jresult;
77811 }
77812
77813
77814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77815   float jresult ;
77816   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77817   float arg2 ;
77818   float arg3 ;
77819   float result;
77820
77821   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77822   arg2 = (float)jarg2;
77823   arg3 = (float)jarg3;
77824   {
77825     try {
77826       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
77827     } catch (std::out_of_range& e) {
77828       {
77829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77830       };
77831     } catch (std::exception& e) {
77832       {
77833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77834       };
77835     } catch (Dali::DaliException e) {
77836       {
77837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77838       };
77839     } catch (...) {
77840       {
77841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77842       };
77843     }
77844   }
77845
77846   jresult = result;
77847   return jresult;
77848 }
77849
77850
77851 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77852   float jresult ;
77853   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77854   unsigned int arg2 ;
77855   unsigned int *arg3 = 0 ;
77856   bool arg4 ;
77857   float result;
77858
77859   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77860   arg2 = (unsigned int)jarg2;
77861   arg3 = (unsigned int *)jarg3;
77862   arg4 = jarg4 ? true : false;
77863   {
77864     try {
77865       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77866     } catch (std::out_of_range& e) {
77867       {
77868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77869       };
77870     } catch (std::exception& e) {
77871       {
77872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77873       };
77874     } catch (Dali::DaliException e) {
77875       {
77876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77877       };
77878     } catch (...) {
77879       {
77880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77881       };
77882     }
77883   }
77884
77885   jresult = result;
77886   return jresult;
77887 }
77888
77889
77890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77891   unsigned int jresult ;
77892   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77893   float arg2 ;
77894   bool arg3 ;
77895   unsigned int result;
77896
77897   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77898   arg2 = (float)jarg2;
77899   arg3 = jarg3 ? true : false;
77900   {
77901     try {
77902       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
77903     } catch (std::out_of_range& e) {
77904       {
77905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77906       };
77907     } catch (std::exception& e) {
77908       {
77909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77910       };
77911     } catch (Dali::DaliException e) {
77912       {
77913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77914       };
77915     } catch (...) {
77916       {
77917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77918       };
77919     }
77920   }
77921
77922   jresult = result;
77923   return jresult;
77924 }
77925
77926
77927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
77928   unsigned int jresult ;
77929   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77930   unsigned int result;
77931
77932   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77933   {
77934     try {
77935       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
77936     } catch (std::out_of_range& e) {
77937       {
77938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77939       };
77940     } catch (std::exception& e) {
77941       {
77942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77943       };
77944     } catch (Dali::DaliException e) {
77945       {
77946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77947       };
77948     } catch (...) {
77949       {
77950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77951       };
77952     }
77953   }
77954
77955   jresult = result;
77956   return jresult;
77957 }
77958
77959
77960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
77961   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77962
77963   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77964   {
77965     try {
77966       delete arg1;
77967     } catch (std::out_of_range& e) {
77968       {
77969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77970       };
77971     } catch (std::exception& e) {
77972       {
77973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77974       };
77975     } catch (Dali::DaliException e) {
77976       {
77977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77978       };
77979     } catch (...) {
77980       {
77981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77982       };
77983     }
77984   }
77985
77986 }
77987
77988
77989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
77990   void * jresult ;
77991   float arg1 ;
77992   Dali::Toolkit::FixedRuler *result = 0 ;
77993
77994   arg1 = (float)jarg1;
77995   {
77996     try {
77997       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
77998     } catch (std::out_of_range& e) {
77999       {
78000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78001       };
78002     } catch (std::exception& e) {
78003       {
78004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78005       };
78006     } catch (Dali::DaliException e) {
78007       {
78008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78009       };
78010     } catch (...) {
78011       {
78012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78013       };
78014     }
78015   }
78016
78017   jresult = (void *)result;
78018   return jresult;
78019 }
78020
78021
78022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
78023   void * jresult ;
78024   Dali::Toolkit::FixedRuler *result = 0 ;
78025
78026   {
78027     try {
78028       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
78029     } catch (std::out_of_range& e) {
78030       {
78031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78032       };
78033     } catch (std::exception& e) {
78034       {
78035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78036       };
78037     } catch (Dali::DaliException e) {
78038       {
78039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78040       };
78041     } catch (...) {
78042       {
78043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78044       };
78045     }
78046   }
78047
78048   jresult = (void *)result;
78049   return jresult;
78050 }
78051
78052
78053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78054   float jresult ;
78055   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78056   float arg2 ;
78057   float arg3 ;
78058   float result;
78059
78060   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78061   arg2 = (float)jarg2;
78062   arg3 = (float)jarg3;
78063   {
78064     try {
78065       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
78066     } catch (std::out_of_range& e) {
78067       {
78068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78069       };
78070     } catch (std::exception& e) {
78071       {
78072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78073       };
78074     } catch (Dali::DaliException e) {
78075       {
78076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78077       };
78078     } catch (...) {
78079       {
78080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78081       };
78082     }
78083   }
78084
78085   jresult = result;
78086   return jresult;
78087 }
78088
78089
78090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78091   float jresult ;
78092   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78093   unsigned int arg2 ;
78094   unsigned int *arg3 = 0 ;
78095   bool arg4 ;
78096   float result;
78097
78098   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78099   arg2 = (unsigned int)jarg2;
78100   arg3 = (unsigned int *)jarg3;
78101   arg4 = jarg4 ? true : false;
78102   {
78103     try {
78104       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78105     } catch (std::out_of_range& e) {
78106       {
78107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78108       };
78109     } catch (std::exception& e) {
78110       {
78111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78112       };
78113     } catch (Dali::DaliException e) {
78114       {
78115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78116       };
78117     } catch (...) {
78118       {
78119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78120       };
78121     }
78122   }
78123
78124   jresult = result;
78125   return jresult;
78126 }
78127
78128
78129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78130   unsigned int jresult ;
78131   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78132   float arg2 ;
78133   bool arg3 ;
78134   unsigned int result;
78135
78136   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78137   arg2 = (float)jarg2;
78138   arg3 = jarg3 ? true : false;
78139   {
78140     try {
78141       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78142     } catch (std::out_of_range& e) {
78143       {
78144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78145       };
78146     } catch (std::exception& e) {
78147       {
78148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78149       };
78150     } catch (Dali::DaliException e) {
78151       {
78152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78153       };
78154     } catch (...) {
78155       {
78156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78157       };
78158     }
78159   }
78160
78161   jresult = result;
78162   return jresult;
78163 }
78164
78165
78166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
78167   unsigned int jresult ;
78168   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78169   unsigned int result;
78170
78171   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78172   {
78173     try {
78174       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
78175     } catch (std::out_of_range& e) {
78176       {
78177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78178       };
78179     } catch (std::exception& e) {
78180       {
78181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78182       };
78183     } catch (Dali::DaliException e) {
78184       {
78185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78186       };
78187     } catch (...) {
78188       {
78189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78190       };
78191     }
78192   }
78193
78194   jresult = result;
78195   return jresult;
78196 }
78197
78198
78199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
78200   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78201
78202   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78203   {
78204     try {
78205       delete arg1;
78206     } catch (std::out_of_range& e) {
78207       {
78208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78209       };
78210     } catch (std::exception& e) {
78211       {
78212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78213       };
78214     } catch (Dali::DaliException e) {
78215       {
78216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78217       };
78218     } catch (...) {
78219       {
78220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78221       };
78222     }
78223   }
78224
78225 }
78226
78227
78228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
78229   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78230   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78231
78232   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78233   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78234   if (arg1) (arg1)->scale = *arg2;
78235 }
78236
78237
78238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
78239   void * jresult ;
78240   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78241   Dali::Toolkit::ClampState2D *result = 0 ;
78242
78243   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78244   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
78245   jresult = (void *)result;
78246   return jresult;
78247 }
78248
78249
78250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
78251   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78252   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78253
78254   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78255   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78256   if (arg1) (arg1)->position = *arg2;
78257 }
78258
78259
78260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
78261   void * jresult ;
78262   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78263   Dali::Toolkit::ClampState2D *result = 0 ;
78264
78265   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78266   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
78267   jresult = (void *)result;
78268   return jresult;
78269 }
78270
78271
78272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
78273   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78274   Dali::Toolkit::ClampState arg2 ;
78275
78276   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78277   arg2 = (Dali::Toolkit::ClampState)jarg2;
78278   if (arg1) (arg1)->rotation = arg2;
78279 }
78280
78281
78282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
78283   int jresult ;
78284   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78285   Dali::Toolkit::ClampState result;
78286
78287   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78288   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
78289   jresult = (int)result;
78290   return jresult;
78291 }
78292
78293
78294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
78295   void * jresult ;
78296   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
78297
78298   {
78299     try {
78300       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
78301     } catch (std::out_of_range& e) {
78302       {
78303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78304       };
78305     } catch (std::exception& e) {
78306       {
78307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78308       };
78309     } catch (Dali::DaliException e) {
78310       {
78311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78312       };
78313     } catch (...) {
78314       {
78315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78316       };
78317     }
78318   }
78319
78320   jresult = (void *)result;
78321   return jresult;
78322 }
78323
78324
78325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
78326   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78327
78328   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78329   {
78330     try {
78331       delete arg1;
78332     } catch (std::out_of_range& e) {
78333       {
78334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78335       };
78336     } catch (std::exception& e) {
78337       {
78338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78339       };
78340     } catch (Dali::DaliException e) {
78341       {
78342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78343       };
78344     } catch (...) {
78345       {
78346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78347       };
78348     }
78349   }
78350
78351 }
78352
78353
78354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
78355   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78356   Dali::Toolkit::SnapType arg2 ;
78357
78358   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78359   arg2 = (Dali::Toolkit::SnapType)jarg2;
78360   if (arg1) (arg1)->type = arg2;
78361 }
78362
78363
78364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
78365   int jresult ;
78366   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78367   Dali::Toolkit::SnapType result;
78368
78369   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78370   result = (Dali::Toolkit::SnapType) ((arg1)->type);
78371   jresult = (int)result;
78372   return jresult;
78373 }
78374
78375
78376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
78377   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78378   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
78379
78380   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78381   arg2 = (Dali::Vector2 *)jarg2;
78382   if (arg1) (arg1)->position = *arg2;
78383 }
78384
78385
78386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
78387   void * jresult ;
78388   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78389   Dali::Vector2 *result = 0 ;
78390
78391   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78392   result = (Dali::Vector2 *)& ((arg1)->position);
78393   jresult = (void *)result;
78394   return jresult;
78395 }
78396
78397
78398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
78399   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78400   float arg2 ;
78401
78402   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78403   arg2 = (float)jarg2;
78404   if (arg1) (arg1)->duration = arg2;
78405 }
78406
78407
78408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
78409   float jresult ;
78410   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78411   float result;
78412
78413   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78414   result = (float) ((arg1)->duration);
78415   jresult = result;
78416   return jresult;
78417 }
78418
78419
78420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
78421   void * jresult ;
78422   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
78423
78424   {
78425     try {
78426       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
78427     } catch (std::out_of_range& e) {
78428       {
78429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78430       };
78431     } catch (std::exception& e) {
78432       {
78433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78434       };
78435     } catch (Dali::DaliException e) {
78436       {
78437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78438       };
78439     } catch (...) {
78440       {
78441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78442       };
78443     }
78444   }
78445
78446   jresult = (void *)result;
78447   return jresult;
78448 }
78449
78450
78451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
78452   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78453
78454   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78455   {
78456     try {
78457       delete arg1;
78458     } catch (std::out_of_range& e) {
78459       {
78460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78461       };
78462     } catch (std::exception& e) {
78463       {
78464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78465       };
78466     } catch (Dali::DaliException e) {
78467       {
78468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78469       };
78470     } catch (...) {
78471       {
78472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78473       };
78474     }
78475   }
78476
78477 }
78478
78479
78480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
78481   int jresult ;
78482   int result;
78483
78484   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
78485   jresult = (int)result;
78486   return jresult;
78487 }
78488
78489
78490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
78491   int jresult ;
78492   int result;
78493
78494   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
78495   jresult = (int)result;
78496   return jresult;
78497 }
78498
78499
78500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
78501   int jresult ;
78502   int result;
78503
78504   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
78505   jresult = (int)result;
78506   return jresult;
78507 }
78508
78509
78510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
78511   int jresult ;
78512   int result;
78513
78514   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
78515   jresult = (int)result;
78516   return jresult;
78517 }
78518
78519
78520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
78521   int jresult ;
78522   int result;
78523
78524   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
78525   jresult = (int)result;
78526   return jresult;
78527 }
78528
78529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
78530   int jresult ;
78531   int result;
78532
78533   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
78534   jresult = (int)result;
78535   return jresult;
78536 }
78537
78538
78539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
78540   int jresult ;
78541   int result;
78542
78543   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
78544   jresult = (int)result;
78545   return jresult;
78546 }
78547
78548
78549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
78550   int jresult ;
78551   int result;
78552
78553   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
78554   jresult = (int)result;
78555   return jresult;
78556 }
78557
78558
78559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
78560   int jresult ;
78561   int result;
78562
78563   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
78564   jresult = (int)result;
78565   return jresult;
78566 }
78567
78568
78569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
78570   int jresult ;
78571   int result;
78572
78573   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
78574   jresult = (int)result;
78575   return jresult;
78576 }
78577
78578
78579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
78580   int jresult ;
78581   int result;
78582
78583   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
78584   jresult = (int)result;
78585   return jresult;
78586 }
78587
78588
78589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
78590   int jresult ;
78591   int result;
78592
78593   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
78594   jresult = (int)result;
78595   return jresult;
78596 }
78597
78598
78599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
78600   int jresult ;
78601   int result;
78602
78603   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
78604   jresult = (int)result;
78605   return jresult;
78606 }
78607
78608
78609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
78610   int jresult ;
78611   int result;
78612
78613   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
78614   jresult = (int)result;
78615   return jresult;
78616 }
78617
78618
78619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
78620   int jresult ;
78621   int result;
78622
78623   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
78624   jresult = (int)result;
78625   return jresult;
78626 }
78627
78628
78629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
78630   int jresult ;
78631   int result;
78632
78633   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
78634   jresult = (int)result;
78635   return jresult;
78636 }
78637
78638
78639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
78640   int jresult ;
78641   int result;
78642
78643   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
78644   jresult = (int)result;
78645   return jresult;
78646 }
78647
78648
78649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
78650   int jresult ;
78651   int result;
78652
78653   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
78654   jresult = (int)result;
78655   return jresult;
78656 }
78657
78658
78659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
78660   int jresult ;
78661   int result;
78662
78663   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
78664   jresult = (int)result;
78665   return jresult;
78666 }
78667
78668
78669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
78670   int jresult ;
78671   int result;
78672
78673   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
78674   jresult = (int)result;
78675   return jresult;
78676 }
78677
78678
78679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
78680   int jresult ;
78681   int result;
78682
78683   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
78684   jresult = (int)result;
78685   return jresult;
78686 }
78687
78688
78689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
78690   int jresult ;
78691   int result;
78692
78693   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
78694   jresult = (int)result;
78695   return jresult;
78696 }
78697
78698
78699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
78700   int jresult ;
78701   int result;
78702
78703   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
78704   jresult = (int)result;
78705   return jresult;
78706 }
78707
78708
78709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
78710   int jresult ;
78711   int result;
78712
78713   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
78714   jresult = (int)result;
78715   return jresult;
78716 }
78717
78718
78719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
78720   int jresult ;
78721   int result;
78722
78723   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
78724   jresult = (int)result;
78725   return jresult;
78726 }
78727
78728
78729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
78730   int jresult ;
78731   int result;
78732
78733   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
78734   jresult = (int)result;
78735   return jresult;
78736 }
78737
78738
78739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
78740   void * jresult ;
78741   Dali::Toolkit::ScrollView::Property *result = 0 ;
78742
78743   {
78744     try {
78745       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
78746     } catch (std::out_of_range& e) {
78747       {
78748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78749       };
78750     } catch (std::exception& e) {
78751       {
78752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78753       };
78754     } catch (Dali::DaliException e) {
78755       {
78756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78757       };
78758     } catch (...) {
78759       {
78760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78761       };
78762     }
78763   }
78764
78765   jresult = (void *)result;
78766   return jresult;
78767 }
78768
78769
78770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
78771   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
78772
78773   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
78774   {
78775     try {
78776       delete arg1;
78777     } catch (std::out_of_range& e) {
78778       {
78779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78780       };
78781     } catch (std::exception& e) {
78782       {
78783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78784       };
78785     } catch (Dali::DaliException e) {
78786       {
78787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78788       };
78789     } catch (...) {
78790       {
78791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78792       };
78793     }
78794   }
78795
78796 }
78797
78798
78799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
78800   void * jresult ;
78801   Dali::Toolkit::ScrollView *result = 0 ;
78802
78803   {
78804     try {
78805       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
78806     } catch (std::out_of_range& e) {
78807       {
78808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78809       };
78810     } catch (std::exception& e) {
78811       {
78812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78813       };
78814     } catch (Dali::DaliException e) {
78815       {
78816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78817       };
78818     } catch (...) {
78819       {
78820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78821       };
78822     }
78823   }
78824
78825   jresult = (void *)result;
78826   return jresult;
78827 }
78828
78829
78830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
78831   void * jresult ;
78832   Dali::Toolkit::ScrollView *arg1 = 0 ;
78833   Dali::Toolkit::ScrollView *result = 0 ;
78834
78835   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78836   if (!arg1) {
78837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78838     return 0;
78839   }
78840   {
78841     try {
78842       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
78843     } catch (std::out_of_range& e) {
78844       {
78845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78846       };
78847     } catch (std::exception& e) {
78848       {
78849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78850       };
78851     } catch (Dali::DaliException e) {
78852       {
78853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78854       };
78855     } catch (...) {
78856       {
78857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78858       };
78859     }
78860   }
78861
78862   jresult = (void *)result;
78863   return jresult;
78864 }
78865
78866
78867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
78868   void * jresult ;
78869   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78870   Dali::Toolkit::ScrollView *arg2 = 0 ;
78871   Dali::Toolkit::ScrollView *result = 0 ;
78872
78873   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78874   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
78875   if (!arg2) {
78876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78877     return 0;
78878   }
78879   {
78880     try {
78881       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
78882     } catch (std::out_of_range& e) {
78883       {
78884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78885       };
78886     } catch (std::exception& e) {
78887       {
78888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78889       };
78890     } catch (Dali::DaliException e) {
78891       {
78892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78893       };
78894     } catch (...) {
78895       {
78896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78897       };
78898     }
78899   }
78900
78901   jresult = (void *)result;
78902   return jresult;
78903 }
78904
78905
78906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
78907   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78908
78909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78910   {
78911     try {
78912       delete arg1;
78913     } catch (std::out_of_range& e) {
78914       {
78915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78916       };
78917     } catch (std::exception& e) {
78918       {
78919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78920       };
78921     } catch (Dali::DaliException e) {
78922       {
78923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78924       };
78925     } catch (...) {
78926       {
78927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78928       };
78929     }
78930   }
78931
78932 }
78933
78934
78935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
78936   void * jresult ;
78937   Dali::Toolkit::ScrollView result;
78938
78939   {
78940     try {
78941       result = Dali::Toolkit::ScrollView::New();
78942     } catch (std::out_of_range& e) {
78943       {
78944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78945       };
78946     } catch (std::exception& e) {
78947       {
78948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78949       };
78950     } catch (Dali::DaliException e) {
78951       {
78952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78953       };
78954     } catch (...) {
78955       {
78956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78957       };
78958     }
78959   }
78960
78961   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78962   return jresult;
78963 }
78964
78965
78966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
78967   void * jresult ;
78968   Dali::BaseHandle arg1 ;
78969   Dali::BaseHandle *argp1 ;
78970   Dali::Toolkit::ScrollView result;
78971
78972   argp1 = (Dali::BaseHandle *)jarg1;
78973   if (!argp1) {
78974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78975     return 0;
78976   }
78977   arg1 = *argp1;
78978   {
78979     try {
78980       result = Dali::Toolkit::ScrollView::DownCast(arg1);
78981     } catch (std::out_of_range& e) {
78982       {
78983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78984       };
78985     } catch (std::exception& e) {
78986       {
78987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78988       };
78989     } catch (Dali::DaliException e) {
78990       {
78991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78992       };
78993     } catch (...) {
78994       {
78995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78996       };
78997     }
78998   }
78999
79000   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79001   return jresult;
79002 }
79003
79004
79005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
79006   void * jresult ;
79007   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79008   Dali::AlphaFunction result;
79009
79010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79011   {
79012     try {
79013       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
79014     } catch (std::out_of_range& e) {
79015       {
79016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79017       };
79018     } catch (std::exception& e) {
79019       {
79020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79021       };
79022     } catch (Dali::DaliException e) {
79023       {
79024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79025       };
79026     } catch (...) {
79027       {
79028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79029       };
79030     }
79031   }
79032
79033   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79034   return jresult;
79035 }
79036
79037
79038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
79039   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79040   Dali::AlphaFunction arg2 ;
79041   Dali::AlphaFunction *argp2 ;
79042
79043   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79044   argp2 = (Dali::AlphaFunction *)jarg2;
79045   if (!argp2) {
79046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79047     return ;
79048   }
79049   arg2 = *argp2;
79050   {
79051     try {
79052       (arg1)->SetScrollSnapAlphaFunction(arg2);
79053     } catch (std::out_of_range& e) {
79054       {
79055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79056       };
79057     } catch (std::exception& e) {
79058       {
79059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79060       };
79061     } catch (Dali::DaliException e) {
79062       {
79063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79064       };
79065     } catch (...) {
79066       {
79067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79068       };
79069     }
79070   }
79071
79072 }
79073
79074
79075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
79076   void * jresult ;
79077   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79078   Dali::AlphaFunction result;
79079
79080   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79081   {
79082     try {
79083       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79084     } catch (std::out_of_range& e) {
79085       {
79086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79087       };
79088     } catch (std::exception& e) {
79089       {
79090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79091       };
79092     } catch (Dali::DaliException e) {
79093       {
79094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79095       };
79096     } catch (...) {
79097       {
79098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79099       };
79100     }
79101   }
79102
79103   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79104   return jresult;
79105 }
79106
79107
79108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79109   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79110   Dali::AlphaFunction arg2 ;
79111   Dali::AlphaFunction *argp2 ;
79112
79113   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79114   argp2 = (Dali::AlphaFunction *)jarg2;
79115   if (!argp2) {
79116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79117     return ;
79118   }
79119   arg2 = *argp2;
79120   {
79121     try {
79122       (arg1)->SetScrollFlickAlphaFunction(arg2);
79123     } catch (std::out_of_range& e) {
79124       {
79125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79126       };
79127     } catch (std::exception& e) {
79128       {
79129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79130       };
79131     } catch (Dali::DaliException e) {
79132       {
79133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79134       };
79135     } catch (...) {
79136       {
79137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79138       };
79139     }
79140   }
79141
79142 }
79143
79144
79145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79146   float jresult ;
79147   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79148   float result;
79149
79150   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79151   {
79152     try {
79153       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
79154     } catch (std::out_of_range& e) {
79155       {
79156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79157       };
79158     } catch (std::exception& e) {
79159       {
79160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79161       };
79162     } catch (Dali::DaliException e) {
79163       {
79164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79165       };
79166     } catch (...) {
79167       {
79168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79169       };
79170     }
79171   }
79172
79173   jresult = result;
79174   return jresult;
79175 }
79176
79177
79178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
79179   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79180   float arg2 ;
79181
79182   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79183   arg2 = (float)jarg2;
79184   {
79185     try {
79186       (arg1)->SetScrollSnapDuration(arg2);
79187     } catch (std::out_of_range& e) {
79188       {
79189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79190       };
79191     } catch (std::exception& e) {
79192       {
79193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79194       };
79195     } catch (Dali::DaliException e) {
79196       {
79197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79198       };
79199     } catch (...) {
79200       {
79201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79202       };
79203     }
79204   }
79205
79206 }
79207
79208
79209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
79210   float jresult ;
79211   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79212   float result;
79213
79214   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79215   {
79216     try {
79217       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
79218     } catch (std::out_of_range& e) {
79219       {
79220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79221       };
79222     } catch (std::exception& e) {
79223       {
79224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79225       };
79226     } catch (Dali::DaliException e) {
79227       {
79228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79229       };
79230     } catch (...) {
79231       {
79232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79233       };
79234     }
79235   }
79236
79237   jresult = result;
79238   return jresult;
79239 }
79240
79241
79242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
79243   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79244   float arg2 ;
79245
79246   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79247   arg2 = (float)jarg2;
79248   {
79249     try {
79250       (arg1)->SetScrollFlickDuration(arg2);
79251     } catch (std::out_of_range& e) {
79252       {
79253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79254       };
79255     } catch (std::exception& e) {
79256       {
79257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79258       };
79259     } catch (Dali::DaliException e) {
79260       {
79261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79262       };
79263     } catch (...) {
79264       {
79265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79266       };
79267     }
79268   }
79269
79270 }
79271
79272
79273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
79274   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79275   Dali::Toolkit::RulerPtr arg2 ;
79276   Dali::Toolkit::RulerPtr *argp2 ;
79277
79278   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79279   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79280   if (!argp2) {
79281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79282     return ;
79283   }
79284   arg2 = *argp2;
79285   {
79286     try {
79287       (arg1)->SetRulerX(arg2);
79288     } catch (std::out_of_range& e) {
79289       {
79290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79291       };
79292     } catch (std::exception& e) {
79293       {
79294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79295       };
79296     } catch (Dali::DaliException e) {
79297       {
79298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79299       };
79300     } catch (...) {
79301       {
79302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79303       };
79304     }
79305   }
79306
79307 }
79308
79309
79310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
79311   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79312   Dali::Toolkit::RulerPtr arg2 ;
79313   Dali::Toolkit::RulerPtr *argp2 ;
79314
79315   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79316   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79317   if (!argp2) {
79318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79319     return ;
79320   }
79321   arg2 = *argp2;
79322   {
79323     try {
79324       (arg1)->SetRulerY(arg2);
79325     } catch (std::out_of_range& e) {
79326       {
79327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79328       };
79329     } catch (std::exception& e) {
79330       {
79331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79332       };
79333     } catch (Dali::DaliException e) {
79334       {
79335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79336       };
79337     } catch (...) {
79338       {
79339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79340       };
79341     }
79342   }
79343
79344 }
79345
79346
79347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
79348   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79349   bool arg2 ;
79350
79351   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79352   arg2 = jarg2 ? true : false;
79353   {
79354     try {
79355       (arg1)->SetScrollSensitive(arg2);
79356     } catch (std::out_of_range& e) {
79357       {
79358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79359       };
79360     } catch (std::exception& e) {
79361       {
79362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79363       };
79364     } catch (Dali::DaliException e) {
79365       {
79366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79367       };
79368     } catch (...) {
79369       {
79370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79371       };
79372     }
79373   }
79374
79375 }
79376
79377
79378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
79379   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79380   float arg2 ;
79381   float arg3 ;
79382
79383   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79384   arg2 = (float)jarg2;
79385   arg3 = (float)jarg3;
79386   {
79387     try {
79388       (arg1)->SetMaxOvershoot(arg2,arg3);
79389     } catch (std::out_of_range& e) {
79390       {
79391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79392       };
79393     } catch (std::exception& e) {
79394       {
79395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79396       };
79397     } catch (Dali::DaliException e) {
79398       {
79399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79400       };
79401     } catch (...) {
79402       {
79403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79404       };
79405     }
79406   }
79407
79408 }
79409
79410
79411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
79412   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79413   Dali::AlphaFunction arg2 ;
79414   Dali::AlphaFunction *argp2 ;
79415
79416   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79417   argp2 = (Dali::AlphaFunction *)jarg2;
79418   if (!argp2) {
79419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79420     return ;
79421   }
79422   arg2 = *argp2;
79423   {
79424     try {
79425       (arg1)->SetSnapOvershootAlphaFunction(arg2);
79426     } catch (std::out_of_range& e) {
79427       {
79428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79429       };
79430     } catch (std::exception& e) {
79431       {
79432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79433       };
79434     } catch (Dali::DaliException e) {
79435       {
79436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79437       };
79438     } catch (...) {
79439       {
79440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79441       };
79442     }
79443   }
79444
79445 }
79446
79447
79448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
79449   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79450   float arg2 ;
79451
79452   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79453   arg2 = (float)jarg2;
79454   {
79455     try {
79456       (arg1)->SetSnapOvershootDuration(arg2);
79457     } catch (std::out_of_range& e) {
79458       {
79459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79460       };
79461     } catch (std::exception& e) {
79462       {
79463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79464       };
79465     } catch (Dali::DaliException e) {
79466       {
79467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79468       };
79469     } catch (...) {
79470       {
79471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79472       };
79473     }
79474   }
79475
79476 }
79477
79478
79479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
79480   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79481   bool arg2 ;
79482
79483   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79484   arg2 = jarg2 ? true : false;
79485   {
79486     try {
79487       (arg1)->SetActorAutoSnap(arg2);
79488     } catch (std::out_of_range& e) {
79489       {
79490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79491       };
79492     } catch (std::exception& e) {
79493       {
79494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79495       };
79496     } catch (Dali::DaliException e) {
79497       {
79498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79499       };
79500     } catch (...) {
79501       {
79502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79503       };
79504     }
79505   }
79506
79507 }
79508
79509
79510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
79511   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79512   bool arg2 ;
79513
79514   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79515   arg2 = jarg2 ? true : false;
79516   {
79517     try {
79518       (arg1)->SetWrapMode(arg2);
79519     } catch (std::out_of_range& e) {
79520       {
79521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79522       };
79523     } catch (std::exception& e) {
79524       {
79525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79526       };
79527     } catch (Dali::DaliException e) {
79528       {
79529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79530       };
79531     } catch (...) {
79532       {
79533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79534       };
79535     }
79536   }
79537
79538 }
79539
79540
79541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
79542   int jresult ;
79543   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79544   int result;
79545
79546   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79547   {
79548     try {
79549       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
79550     } catch (std::out_of_range& e) {
79551       {
79552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79553       };
79554     } catch (std::exception& e) {
79555       {
79556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79557       };
79558     } catch (Dali::DaliException e) {
79559       {
79560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79561       };
79562     } catch (...) {
79563       {
79564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79565       };
79566     }
79567   }
79568
79569   jresult = result;
79570   return jresult;
79571 }
79572
79573
79574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
79575   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79576   int arg2 ;
79577
79578   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79579   arg2 = (int)jarg2;
79580   {
79581     try {
79582       (arg1)->SetScrollUpdateDistance(arg2);
79583     } catch (std::out_of_range& e) {
79584       {
79585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79586       };
79587     } catch (std::exception& e) {
79588       {
79589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79590       };
79591     } catch (Dali::DaliException e) {
79592       {
79593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79594       };
79595     } catch (...) {
79596       {
79597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79598       };
79599     }
79600   }
79601
79602 }
79603
79604
79605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
79606   unsigned int jresult ;
79607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79608   bool result;
79609
79610   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79611   {
79612     try {
79613       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
79614     } catch (std::out_of_range& e) {
79615       {
79616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79617       };
79618     } catch (std::exception& e) {
79619       {
79620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79621       };
79622     } catch (Dali::DaliException e) {
79623       {
79624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79625       };
79626     } catch (...) {
79627       {
79628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79629       };
79630     }
79631   }
79632
79633   jresult = result;
79634   return jresult;
79635 }
79636
79637
79638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
79639   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79640   bool arg2 ;
79641
79642   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79643   arg2 = jarg2 ? true : false;
79644   {
79645     try {
79646       (arg1)->SetAxisAutoLock(arg2);
79647     } catch (std::out_of_range& e) {
79648       {
79649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79650       };
79651     } catch (std::exception& e) {
79652       {
79653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79654       };
79655     } catch (Dali::DaliException e) {
79656       {
79657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79658       };
79659     } catch (...) {
79660       {
79661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79662       };
79663     }
79664   }
79665
79666 }
79667
79668
79669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
79670   float jresult ;
79671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79672   float result;
79673
79674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79675   {
79676     try {
79677       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
79678     } catch (std::out_of_range& e) {
79679       {
79680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79681       };
79682     } catch (std::exception& e) {
79683       {
79684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79685       };
79686     } catch (Dali::DaliException e) {
79687       {
79688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79689       };
79690     } catch (...) {
79691       {
79692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79693       };
79694     }
79695   }
79696
79697   jresult = result;
79698   return jresult;
79699 }
79700
79701
79702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
79703   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79704   float arg2 ;
79705
79706   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79707   arg2 = (float)jarg2;
79708   {
79709     try {
79710       (arg1)->SetAxisAutoLockGradient(arg2);
79711     } catch (std::out_of_range& e) {
79712       {
79713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79714       };
79715     } catch (std::exception& e) {
79716       {
79717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79718       };
79719     } catch (Dali::DaliException e) {
79720       {
79721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79722       };
79723     } catch (...) {
79724       {
79725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79726       };
79727     }
79728   }
79729
79730 }
79731
79732
79733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
79734   float jresult ;
79735   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79736   float result;
79737
79738   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79739   {
79740     try {
79741       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
79742     } catch (std::out_of_range& e) {
79743       {
79744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79745       };
79746     } catch (std::exception& e) {
79747       {
79748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79749       };
79750     } catch (Dali::DaliException e) {
79751       {
79752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79753       };
79754     } catch (...) {
79755       {
79756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79757       };
79758     }
79759   }
79760
79761   jresult = result;
79762   return jresult;
79763 }
79764
79765
79766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
79767   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79768   float arg2 ;
79769
79770   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79771   arg2 = (float)jarg2;
79772   {
79773     try {
79774       (arg1)->SetFrictionCoefficient(arg2);
79775     } catch (std::out_of_range& e) {
79776       {
79777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79778       };
79779     } catch (std::exception& e) {
79780       {
79781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79782       };
79783     } catch (Dali::DaliException e) {
79784       {
79785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79786       };
79787     } catch (...) {
79788       {
79789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79790       };
79791     }
79792   }
79793
79794 }
79795
79796
79797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
79798   float jresult ;
79799   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79800   float result;
79801
79802   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79803   {
79804     try {
79805       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
79806     } catch (std::out_of_range& e) {
79807       {
79808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79809       };
79810     } catch (std::exception& e) {
79811       {
79812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79813       };
79814     } catch (Dali::DaliException e) {
79815       {
79816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79817       };
79818     } catch (...) {
79819       {
79820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79821       };
79822     }
79823   }
79824
79825   jresult = result;
79826   return jresult;
79827 }
79828
79829
79830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
79831   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79832   float arg2 ;
79833
79834   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79835   arg2 = (float)jarg2;
79836   {
79837     try {
79838       (arg1)->SetFlickSpeedCoefficient(arg2);
79839     } catch (std::out_of_range& e) {
79840       {
79841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79842       };
79843     } catch (std::exception& e) {
79844       {
79845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79846       };
79847     } catch (Dali::DaliException e) {
79848       {
79849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79850       };
79851     } catch (...) {
79852       {
79853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79854       };
79855     }
79856   }
79857
79858 }
79859
79860
79861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
79862   void * jresult ;
79863   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79864   Dali::Vector2 result;
79865
79866   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79867   {
79868     try {
79869       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
79870     } catch (std::out_of_range& e) {
79871       {
79872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79873       };
79874     } catch (std::exception& e) {
79875       {
79876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79877       };
79878     } catch (Dali::DaliException e) {
79879       {
79880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79881       };
79882     } catch (...) {
79883       {
79884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79885       };
79886     }
79887   }
79888
79889   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79890   return jresult;
79891 }
79892
79893
79894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
79895   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79896   Dali::Vector2 *arg2 = 0 ;
79897
79898   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79899   arg2 = (Dali::Vector2 *)jarg2;
79900   if (!arg2) {
79901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79902     return ;
79903   }
79904   {
79905     try {
79906       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
79907     } catch (std::out_of_range& e) {
79908       {
79909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79910       };
79911     } catch (std::exception& e) {
79912       {
79913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79914       };
79915     } catch (Dali::DaliException e) {
79916       {
79917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79918       };
79919     } catch (...) {
79920       {
79921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79922       };
79923     }
79924   }
79925
79926 }
79927
79928
79929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
79930   float jresult ;
79931   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79932   float result;
79933
79934   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79935   {
79936     try {
79937       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
79938     } catch (std::out_of_range& e) {
79939       {
79940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79941       };
79942     } catch (std::exception& e) {
79943       {
79944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79945       };
79946     } catch (Dali::DaliException e) {
79947       {
79948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79949       };
79950     } catch (...) {
79951       {
79952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79953       };
79954     }
79955   }
79956
79957   jresult = result;
79958   return jresult;
79959 }
79960
79961
79962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
79963   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79964   float arg2 ;
79965
79966   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79967   arg2 = (float)jarg2;
79968   {
79969     try {
79970       (arg1)->SetMinimumSpeedForFlick(arg2);
79971     } catch (std::out_of_range& e) {
79972       {
79973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79974       };
79975     } catch (std::exception& e) {
79976       {
79977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79978       };
79979     } catch (Dali::DaliException e) {
79980       {
79981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79982       };
79983     } catch (...) {
79984       {
79985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79986       };
79987     }
79988   }
79989
79990 }
79991
79992
79993 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
79994   float jresult ;
79995   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79996   float result;
79997
79998   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79999   {
80000     try {
80001       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
80002     } catch (std::out_of_range& e) {
80003       {
80004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80005       };
80006     } catch (std::exception& e) {
80007       {
80008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80009       };
80010     } catch (Dali::DaliException e) {
80011       {
80012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80013       };
80014     } catch (...) {
80015       {
80016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80017       };
80018     }
80019   }
80020
80021   jresult = result;
80022   return jresult;
80023 }
80024
80025
80026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
80027   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80028   float arg2 ;
80029
80030   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80031   arg2 = (float)jarg2;
80032   {
80033     try {
80034       (arg1)->SetMaxFlickSpeed(arg2);
80035     } catch (std::out_of_range& e) {
80036       {
80037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80038       };
80039     } catch (std::exception& e) {
80040       {
80041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80042       };
80043     } catch (Dali::DaliException e) {
80044       {
80045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80046       };
80047     } catch (...) {
80048       {
80049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80050       };
80051     }
80052   }
80053
80054 }
80055
80056
80057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
80058   void * jresult ;
80059   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80060   Dali::Vector2 result;
80061
80062   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80063   {
80064     try {
80065       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
80066     } catch (std::out_of_range& e) {
80067       {
80068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80069       };
80070     } catch (std::exception& e) {
80071       {
80072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80073       };
80074     } catch (Dali::DaliException e) {
80075       {
80076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80077       };
80078     } catch (...) {
80079       {
80080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80081       };
80082     }
80083   }
80084
80085   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80086   return jresult;
80087 }
80088
80089
80090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80091   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80092   Dali::Vector2 arg2 ;
80093   Dali::Vector2 *argp2 ;
80094
80095   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80096   argp2 = (Dali::Vector2 *)jarg2;
80097   if (!argp2) {
80098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80099     return ;
80100   }
80101   arg2 = *argp2;
80102   {
80103     try {
80104       (arg1)->SetWheelScrollDistanceStep(arg2);
80105     } catch (std::out_of_range& e) {
80106       {
80107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80108       };
80109     } catch (std::exception& e) {
80110       {
80111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80112       };
80113     } catch (Dali::DaliException e) {
80114       {
80115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80116       };
80117     } catch (...) {
80118       {
80119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80120       };
80121     }
80122   }
80123
80124 }
80125
80126
80127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80128   void * jresult ;
80129   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80130   Dali::Vector2 result;
80131
80132   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80133   {
80134     try {
80135       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80136     } catch (std::out_of_range& e) {
80137       {
80138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80139       };
80140     } catch (std::exception& e) {
80141       {
80142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80143       };
80144     } catch (Dali::DaliException e) {
80145       {
80146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80147       };
80148     } catch (...) {
80149       {
80150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80151       };
80152     }
80153   }
80154
80155   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80156   return jresult;
80157 }
80158
80159
80160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
80161   unsigned int jresult ;
80162   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80163   unsigned int result;
80164
80165   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80166   {
80167     try {
80168       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
80169     } catch (std::out_of_range& e) {
80170       {
80171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80172       };
80173     } catch (std::exception& e) {
80174       {
80175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80176       };
80177     } catch (Dali::DaliException e) {
80178       {
80179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80180       };
80181     } catch (...) {
80182       {
80183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80184       };
80185     }
80186   }
80187
80188   jresult = result;
80189   return jresult;
80190 }
80191
80192
80193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
80194   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80195   Dali::Vector2 *arg2 = 0 ;
80196
80197   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80198   arg2 = (Dali::Vector2 *)jarg2;
80199   if (!arg2) {
80200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80201     return ;
80202   }
80203   {
80204     try {
80205       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
80206     } catch (std::out_of_range& e) {
80207       {
80208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80209       };
80210     } catch (std::exception& e) {
80211       {
80212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80213       };
80214     } catch (Dali::DaliException e) {
80215       {
80216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80217       };
80218     } catch (...) {
80219       {
80220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80221       };
80222     }
80223   }
80224
80225 }
80226
80227
80228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
80229   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80230   Dali::Vector2 *arg2 = 0 ;
80231   float arg3 ;
80232
80233   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80234   arg2 = (Dali::Vector2 *)jarg2;
80235   if (!arg2) {
80236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80237     return ;
80238   }
80239   arg3 = (float)jarg3;
80240   {
80241     try {
80242       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
80243     } catch (std::out_of_range& e) {
80244       {
80245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80246       };
80247     } catch (std::exception& e) {
80248       {
80249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80250       };
80251     } catch (Dali::DaliException e) {
80252       {
80253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80254       };
80255     } catch (...) {
80256       {
80257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80258       };
80259     }
80260   }
80261
80262 }
80263
80264
80265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
80266   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80267   Dali::Vector2 *arg2 = 0 ;
80268   float arg3 ;
80269   Dali::AlphaFunction arg4 ;
80270   Dali::AlphaFunction *argp4 ;
80271
80272   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80273   arg2 = (Dali::Vector2 *)jarg2;
80274   if (!arg2) {
80275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80276     return ;
80277   }
80278   arg3 = (float)jarg3;
80279   argp4 = (Dali::AlphaFunction *)jarg4;
80280   if (!argp4) {
80281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80282     return ;
80283   }
80284   arg4 = *argp4;
80285   {
80286     try {
80287       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
80288     } catch (std::out_of_range& e) {
80289       {
80290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80291       };
80292     } catch (std::exception& e) {
80293       {
80294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80295       };
80296     } catch (Dali::DaliException e) {
80297       {
80298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80299       };
80300     } catch (...) {
80301       {
80302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80303       };
80304     }
80305   }
80306
80307 }
80308
80309
80310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
80311   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80312   Dali::Vector2 *arg2 = 0 ;
80313   float arg3 ;
80314   Dali::Toolkit::DirectionBias arg4 ;
80315   Dali::Toolkit::DirectionBias arg5 ;
80316
80317   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80318   arg2 = (Dali::Vector2 *)jarg2;
80319   if (!arg2) {
80320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80321     return ;
80322   }
80323   arg3 = (float)jarg3;
80324   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80325   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80326   {
80327     try {
80328       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
80329     } catch (std::out_of_range& e) {
80330       {
80331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80332       };
80333     } catch (std::exception& e) {
80334       {
80335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80336       };
80337     } catch (Dali::DaliException e) {
80338       {
80339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80340       };
80341     } catch (...) {
80342       {
80343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80344       };
80345     }
80346   }
80347
80348 }
80349
80350
80351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
80352   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80353   Dali::Vector2 *arg2 = 0 ;
80354   float arg3 ;
80355   Dali::AlphaFunction arg4 ;
80356   Dali::Toolkit::DirectionBias arg5 ;
80357   Dali::Toolkit::DirectionBias arg6 ;
80358   Dali::AlphaFunction *argp4 ;
80359
80360   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80361   arg2 = (Dali::Vector2 *)jarg2;
80362   if (!arg2) {
80363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80364     return ;
80365   }
80366   arg3 = (float)jarg3;
80367   argp4 = (Dali::AlphaFunction *)jarg4;
80368   if (!argp4) {
80369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80370     return ;
80371   }
80372   arg4 = *argp4;
80373   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80374   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
80375   {
80376     try {
80377       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
80378     } catch (std::out_of_range& e) {
80379       {
80380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80381       };
80382     } catch (std::exception& e) {
80383       {
80384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80385       };
80386     } catch (Dali::DaliException e) {
80387       {
80388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80389       };
80390     } catch (...) {
80391       {
80392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80393       };
80394     }
80395   }
80396
80397 }
80398
80399
80400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
80401   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80402   unsigned int arg2 ;
80403
80404   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80405   arg2 = (unsigned int)jarg2;
80406   {
80407     try {
80408       (arg1)->ScrollTo(arg2);
80409     } catch (std::out_of_range& e) {
80410       {
80411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80412       };
80413     } catch (std::exception& e) {
80414       {
80415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80416       };
80417     } catch (Dali::DaliException e) {
80418       {
80419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80420       };
80421     } catch (...) {
80422       {
80423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80424       };
80425     }
80426   }
80427
80428 }
80429
80430
80431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
80432   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80433   unsigned int arg2 ;
80434   float arg3 ;
80435
80436   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80437   arg2 = (unsigned int)jarg2;
80438   arg3 = (float)jarg3;
80439   {
80440     try {
80441       (arg1)->ScrollTo(arg2,arg3);
80442     } catch (std::out_of_range& e) {
80443       {
80444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80445       };
80446     } catch (std::exception& e) {
80447       {
80448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80449       };
80450     } catch (Dali::DaliException e) {
80451       {
80452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80453       };
80454     } catch (...) {
80455       {
80456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80457       };
80458     }
80459   }
80460
80461 }
80462
80463
80464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
80465   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80466   unsigned int arg2 ;
80467   float arg3 ;
80468   Dali::Toolkit::DirectionBias arg4 ;
80469
80470   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80471   arg2 = (unsigned int)jarg2;
80472   arg3 = (float)jarg3;
80473   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80474   {
80475     try {
80476       (arg1)->ScrollTo(arg2,arg3,arg4);
80477     } catch (std::out_of_range& e) {
80478       {
80479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80480       };
80481     } catch (std::exception& e) {
80482       {
80483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80484       };
80485     } catch (Dali::DaliException e) {
80486       {
80487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80488       };
80489     } catch (...) {
80490       {
80491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80492       };
80493     }
80494   }
80495
80496 }
80497
80498
80499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
80500   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80501   Dali::Actor *arg2 = 0 ;
80502
80503   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80504   arg2 = (Dali::Actor *)jarg2;
80505   if (!arg2) {
80506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80507     return ;
80508   }
80509   {
80510     try {
80511       (arg1)->ScrollTo(*arg2);
80512     } catch (std::out_of_range& e) {
80513       {
80514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80515       };
80516     } catch (std::exception& e) {
80517       {
80518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80519       };
80520     } catch (Dali::DaliException e) {
80521       {
80522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80523       };
80524     } catch (...) {
80525       {
80526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80527       };
80528     }
80529   }
80530
80531 }
80532
80533
80534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
80535   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80536   Dali::Actor *arg2 = 0 ;
80537   float arg3 ;
80538
80539   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80540   arg2 = (Dali::Actor *)jarg2;
80541   if (!arg2) {
80542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80543     return ;
80544   }
80545   arg3 = (float)jarg3;
80546   {
80547     try {
80548       (arg1)->ScrollTo(*arg2,arg3);
80549     } catch (std::out_of_range& e) {
80550       {
80551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80552       };
80553     } catch (std::exception& e) {
80554       {
80555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80556       };
80557     } catch (Dali::DaliException e) {
80558       {
80559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80560       };
80561     } catch (...) {
80562       {
80563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80564       };
80565     }
80566   }
80567
80568 }
80569
80570
80571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
80572   unsigned int jresult ;
80573   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80574   bool result;
80575
80576   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80577   {
80578     try {
80579       result = (bool)(arg1)->ScrollToSnapPoint();
80580     } catch (std::out_of_range& e) {
80581       {
80582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80583       };
80584     } catch (std::exception& e) {
80585       {
80586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80587       };
80588     } catch (Dali::DaliException e) {
80589       {
80590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80591       };
80592     } catch (...) {
80593       {
80594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80595       };
80596     }
80597   }
80598
80599   jresult = result;
80600   return jresult;
80601 }
80602
80603
80604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
80605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80606   Dali::Constraint arg2 ;
80607   Dali::Constraint *argp2 ;
80608
80609   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80610   argp2 = (Dali::Constraint *)jarg2;
80611   if (!argp2) {
80612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
80613     return ;
80614   }
80615   arg2 = *argp2;
80616   {
80617     try {
80618       (arg1)->ApplyConstraintToChildren(arg2);
80619     } catch (std::out_of_range& e) {
80620       {
80621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80622       };
80623     } catch (std::exception& e) {
80624       {
80625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80626       };
80627     } catch (Dali::DaliException e) {
80628       {
80629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80630       };
80631     } catch (...) {
80632       {
80633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80634       };
80635     }
80636   }
80637
80638 }
80639
80640
80641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
80642   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80643
80644   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80645   {
80646     try {
80647       (arg1)->RemoveConstraintsFromChildren();
80648     } catch (std::out_of_range& e) {
80649       {
80650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80651       };
80652     } catch (std::exception& e) {
80653       {
80654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80655       };
80656     } catch (Dali::DaliException e) {
80657       {
80658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80659       };
80660     } catch (...) {
80661       {
80662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80663       };
80664     }
80665   }
80666
80667 }
80668
80669
80670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
80671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80672   Dali::Toolkit::ScrollViewEffect arg2 ;
80673   Dali::Toolkit::ScrollViewEffect *argp2 ;
80674
80675   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80676   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80677   if (!argp2) {
80678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80679     return ;
80680   }
80681   arg2 = *argp2;
80682   {
80683     try {
80684       (arg1)->ApplyEffect(arg2);
80685     } catch (std::out_of_range& e) {
80686       {
80687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80688       };
80689     } catch (std::exception& e) {
80690       {
80691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80692       };
80693     } catch (Dali::DaliException e) {
80694       {
80695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80696       };
80697     } catch (...) {
80698       {
80699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80700       };
80701     }
80702   }
80703
80704 }
80705
80706
80707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
80708   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80709   Dali::Toolkit::ScrollViewEffect arg2 ;
80710   Dali::Toolkit::ScrollViewEffect *argp2 ;
80711
80712   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80713   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80714   if (!argp2) {
80715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80716     return ;
80717   }
80718   arg2 = *argp2;
80719   {
80720     try {
80721       (arg1)->RemoveEffect(arg2);
80722     } catch (std::out_of_range& e) {
80723       {
80724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80725       };
80726     } catch (std::exception& e) {
80727       {
80728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80729       };
80730     } catch (Dali::DaliException e) {
80731       {
80732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80733       };
80734     } catch (...) {
80735       {
80736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80737       };
80738     }
80739   }
80740
80741 }
80742
80743
80744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
80745   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80746
80747   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80748   {
80749     try {
80750       (arg1)->RemoveAllEffects();
80751     } catch (std::out_of_range& e) {
80752       {
80753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80754       };
80755     } catch (std::exception& e) {
80756       {
80757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80758       };
80759     } catch (Dali::DaliException e) {
80760       {
80761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80762       };
80763     } catch (...) {
80764       {
80765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80766       };
80767     }
80768   }
80769
80770 }
80771
80772
80773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
80774   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80775   Dali::Actor arg2 ;
80776   Dali::Actor *argp2 ;
80777
80778   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80779   argp2 = (Dali::Actor *)jarg2;
80780   if (!argp2) {
80781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80782     return ;
80783   }
80784   arg2 = *argp2;
80785   {
80786     try {
80787       (arg1)->BindActor(arg2);
80788     } catch (std::out_of_range& e) {
80789       {
80790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80791       };
80792     } catch (std::exception& e) {
80793       {
80794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80795       };
80796     } catch (Dali::DaliException e) {
80797       {
80798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80799       };
80800     } catch (...) {
80801       {
80802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80803       };
80804     }
80805   }
80806
80807 }
80808
80809
80810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
80811   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80812   Dali::Actor arg2 ;
80813   Dali::Actor *argp2 ;
80814
80815   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80816   argp2 = (Dali::Actor *)jarg2;
80817   if (!argp2) {
80818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80819     return ;
80820   }
80821   arg2 = *argp2;
80822   {
80823     try {
80824       (arg1)->UnbindActor(arg2);
80825     } catch (std::out_of_range& e) {
80826       {
80827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80828       };
80829     } catch (std::exception& e) {
80830       {
80831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80832       };
80833     } catch (Dali::DaliException e) {
80834       {
80835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80836       };
80837     } catch (...) {
80838       {
80839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80840       };
80841     }
80842   }
80843
80844 }
80845
80846
80847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
80848   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80849   Dali::Radian arg2 ;
80850   Dali::Radian arg3 ;
80851   Dali::Radian *argp2 ;
80852   Dali::Radian *argp3 ;
80853
80854   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80855   argp2 = (Dali::Radian *)jarg2;
80856   if (!argp2) {
80857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80858     return ;
80859   }
80860   arg2 = *argp2;
80861   argp3 = (Dali::Radian *)jarg3;
80862   if (!argp3) {
80863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80864     return ;
80865   }
80866   arg3 = *argp3;
80867   {
80868     try {
80869       (arg1)->SetScrollingDirection(arg2,arg3);
80870     } catch (std::out_of_range& e) {
80871       {
80872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80873       };
80874     } catch (std::exception& e) {
80875       {
80876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80877       };
80878     } catch (Dali::DaliException e) {
80879       {
80880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80881       };
80882     } catch (...) {
80883       {
80884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80885       };
80886     }
80887   }
80888
80889 }
80890
80891
80892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
80893   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80894   Dali::Radian arg2 ;
80895   Dali::Radian *argp2 ;
80896
80897   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80898   argp2 = (Dali::Radian *)jarg2;
80899   if (!argp2) {
80900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80901     return ;
80902   }
80903   arg2 = *argp2;
80904   {
80905     try {
80906       (arg1)->SetScrollingDirection(arg2);
80907     } catch (std::out_of_range& e) {
80908       {
80909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80910       };
80911     } catch (std::exception& e) {
80912       {
80913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80914       };
80915     } catch (Dali::DaliException e) {
80916       {
80917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80918       };
80919     } catch (...) {
80920       {
80921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80922       };
80923     }
80924   }
80925
80926 }
80927
80928
80929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
80930   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80931   Dali::Radian arg2 ;
80932   Dali::Radian *argp2 ;
80933
80934   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80935   argp2 = (Dali::Radian *)jarg2;
80936   if (!argp2) {
80937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80938     return ;
80939   }
80940   arg2 = *argp2;
80941   {
80942     try {
80943       (arg1)->RemoveScrollingDirection(arg2);
80944     } catch (std::out_of_range& e) {
80945       {
80946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80947       };
80948     } catch (std::exception& e) {
80949       {
80950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80951       };
80952     } catch (Dali::DaliException e) {
80953       {
80954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80955       };
80956     } catch (...) {
80957       {
80958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80959       };
80960     }
80961   }
80962
80963 }
80964
80965
80966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
80967   void * jresult ;
80968   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80969   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
80970
80971   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80972   {
80973     try {
80974       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
80975     } catch (std::out_of_range& e) {
80976       {
80977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80978       };
80979     } catch (std::exception& e) {
80980       {
80981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80982       };
80983     } catch (Dali::DaliException e) {
80984       {
80985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80986       };
80987     } catch (...) {
80988       {
80989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80990       };
80991     }
80992   }
80993
80994   jresult = (void *)result;
80995   return jresult;
80996 }
80997
80998
80999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
81000   int jresult ;
81001   int result;
81002
81003   result = (int)Dali::Toolkit::TableView::Property::ROWS;
81004   jresult = (int)result;
81005   return jresult;
81006 }
81007
81008
81009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
81010   int jresult ;
81011   int result;
81012
81013   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
81014   jresult = (int)result;
81015   return jresult;
81016 }
81017
81018
81019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
81020   int jresult ;
81021   int result;
81022
81023   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
81024   jresult = (int)result;
81025   return jresult;
81026 }
81027
81028
81029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
81030   int jresult ;
81031   int result;
81032
81033   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
81034   jresult = (int)result;
81035   return jresult;
81036 }
81037
81038
81039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
81040   int jresult ;
81041   int result;
81042
81043   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
81044   jresult = (int)result;
81045   return jresult;
81046 }
81047
81048
81049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
81050   void * jresult ;
81051   Dali::Toolkit::TableView::Property *result = 0 ;
81052
81053   {
81054     try {
81055       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
81056     } catch (std::out_of_range& e) {
81057       {
81058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81059       };
81060     } catch (std::exception& e) {
81061       {
81062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81063       };
81064     } catch (Dali::DaliException e) {
81065       {
81066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81067       };
81068     } catch (...) {
81069       {
81070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81071       };
81072     }
81073   }
81074
81075   jresult = (void *)result;
81076   return jresult;
81077 }
81078
81079
81080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81081   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81082
81083   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81084   {
81085     try {
81086       delete arg1;
81087     } catch (std::out_of_range& e) {
81088       {
81089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81090       };
81091     } catch (std::exception& e) {
81092       {
81093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81094       };
81095     } catch (Dali::DaliException e) {
81096       {
81097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81098       };
81099     } catch (...) {
81100       {
81101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81102       };
81103     }
81104   }
81105
81106 }
81107
81108
81109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81110   int jresult ;
81111   int result;
81112
81113   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81114   jresult = (int)result;
81115   return jresult;
81116 }
81117
81118
81119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81120   int jresult ;
81121   int result;
81122
81123   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81124   jresult = (int)result;
81125   return jresult;
81126 }
81127
81128
81129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81130   int jresult ;
81131   int result;
81132
81133   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81134   jresult = (int)result;
81135   return jresult;
81136 }
81137
81138
81139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81140   int jresult ;
81141   int result;
81142
81143   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81144   jresult = (int)result;
81145   return jresult;
81146 }
81147
81148
81149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
81150   int jresult ;
81151   int result;
81152
81153   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
81154   jresult = (int)result;
81155   return jresult;
81156 }
81157
81158
81159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
81160   void * jresult ;
81161   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
81162
81163   {
81164     try {
81165       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
81166     } catch (std::out_of_range& e) {
81167       {
81168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81169       };
81170     } catch (std::exception& e) {
81171       {
81172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81173       };
81174     } catch (Dali::DaliException e) {
81175       {
81176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81177       };
81178     } catch (...) {
81179       {
81180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81181       };
81182     }
81183   }
81184
81185   jresult = (void *)result;
81186   return jresult;
81187 }
81188
81189
81190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
81191   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
81192
81193   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
81194   {
81195     try {
81196       delete arg1;
81197     } catch (std::out_of_range& e) {
81198       {
81199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81200       };
81201     } catch (std::exception& e) {
81202       {
81203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81204       };
81205     } catch (Dali::DaliException e) {
81206       {
81207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81208       };
81209     } catch (...) {
81210       {
81211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81212       };
81213     }
81214   }
81215
81216 }
81217
81218
81219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
81220   void * jresult ;
81221   unsigned int arg1 ;
81222   unsigned int arg2 ;
81223   unsigned int arg3 ;
81224   unsigned int arg4 ;
81225   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81226
81227   arg1 = (unsigned int)jarg1;
81228   arg2 = (unsigned int)jarg2;
81229   arg3 = (unsigned int)jarg3;
81230   arg4 = (unsigned int)jarg4;
81231   {
81232     try {
81233       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
81234     } catch (std::out_of_range& e) {
81235       {
81236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81237       };
81238     } catch (std::exception& e) {
81239       {
81240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81241       };
81242     } catch (Dali::DaliException e) {
81243       {
81244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81245       };
81246     } catch (...) {
81247       {
81248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81249       };
81250     }
81251   }
81252
81253   jresult = (void *)result;
81254   return jresult;
81255 }
81256
81257
81258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
81259   void * jresult ;
81260   unsigned int arg1 ;
81261   unsigned int arg2 ;
81262   unsigned int arg3 ;
81263   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81264
81265   arg1 = (unsigned int)jarg1;
81266   arg2 = (unsigned int)jarg2;
81267   arg3 = (unsigned int)jarg3;
81268   {
81269     try {
81270       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
81271     } catch (std::out_of_range& e) {
81272       {
81273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81274       };
81275     } catch (std::exception& e) {
81276       {
81277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81278       };
81279     } catch (Dali::DaliException e) {
81280       {
81281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81282       };
81283     } catch (...) {
81284       {
81285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81286       };
81287     }
81288   }
81289
81290   jresult = (void *)result;
81291   return jresult;
81292 }
81293
81294
81295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
81296   void * jresult ;
81297   unsigned int arg1 ;
81298   unsigned int arg2 ;
81299   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81300
81301   arg1 = (unsigned int)jarg1;
81302   arg2 = (unsigned int)jarg2;
81303   {
81304     try {
81305       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
81306     } catch (std::out_of_range& e) {
81307       {
81308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81309       };
81310     } catch (std::exception& e) {
81311       {
81312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81313       };
81314     } catch (Dali::DaliException e) {
81315       {
81316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81317       };
81318     } catch (...) {
81319       {
81320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81321       };
81322     }
81323   }
81324
81325   jresult = (void *)result;
81326   return jresult;
81327 }
81328
81329
81330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
81331   void * jresult ;
81332   unsigned int arg1 ;
81333   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81334
81335   arg1 = (unsigned int)jarg1;
81336   {
81337     try {
81338       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
81339     } catch (std::out_of_range& e) {
81340       {
81341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81342       };
81343     } catch (std::exception& e) {
81344       {
81345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81346       };
81347     } catch (Dali::DaliException e) {
81348       {
81349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81350       };
81351     } catch (...) {
81352       {
81353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81354       };
81355     }
81356   }
81357
81358   jresult = (void *)result;
81359   return jresult;
81360 }
81361
81362
81363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
81364   void * jresult ;
81365   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81366
81367   {
81368     try {
81369       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
81370     } catch (std::out_of_range& e) {
81371       {
81372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81373       };
81374     } catch (std::exception& e) {
81375       {
81376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81377       };
81378     } catch (Dali::DaliException e) {
81379       {
81380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81381       };
81382     } catch (...) {
81383       {
81384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81385       };
81386     }
81387   }
81388
81389   jresult = (void *)result;
81390   return jresult;
81391 }
81392
81393
81394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
81395   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81396   unsigned int arg2 ;
81397
81398   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81399   arg2 = (unsigned int)jarg2;
81400   if (arg1) (arg1)->rowIndex = arg2;
81401 }
81402
81403
81404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
81405   unsigned int jresult ;
81406   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81407   unsigned int result;
81408
81409   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81410   result = (unsigned int) ((arg1)->rowIndex);
81411   jresult = result;
81412   return jresult;
81413 }
81414
81415
81416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
81417   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81418   unsigned int arg2 ;
81419
81420   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81421   arg2 = (unsigned int)jarg2;
81422   if (arg1) (arg1)->columnIndex = arg2;
81423 }
81424
81425
81426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
81427   unsigned int jresult ;
81428   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81429   unsigned int result;
81430
81431   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81432   result = (unsigned int) ((arg1)->columnIndex);
81433   jresult = result;
81434   return jresult;
81435 }
81436
81437
81438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
81439   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81440   unsigned int arg2 ;
81441
81442   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81443   arg2 = (unsigned int)jarg2;
81444   if (arg1) (arg1)->rowSpan = arg2;
81445 }
81446
81447
81448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
81449   unsigned int jresult ;
81450   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81451   unsigned int result;
81452
81453   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81454   result = (unsigned int) ((arg1)->rowSpan);
81455   jresult = result;
81456   return jresult;
81457 }
81458
81459
81460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
81461   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81462   unsigned int arg2 ;
81463
81464   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81465   arg2 = (unsigned int)jarg2;
81466   if (arg1) (arg1)->columnSpan = arg2;
81467 }
81468
81469
81470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
81471   unsigned int jresult ;
81472   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81473   unsigned int result;
81474
81475   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81476   result = (unsigned int) ((arg1)->columnSpan);
81477   jresult = result;
81478   return jresult;
81479 }
81480
81481
81482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
81483   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81484
81485   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81486   {
81487     try {
81488       delete arg1;
81489     } catch (std::out_of_range& e) {
81490       {
81491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81492       };
81493     } catch (std::exception& e) {
81494       {
81495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81496       };
81497     } catch (Dali::DaliException e) {
81498       {
81499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81500       };
81501     } catch (...) {
81502       {
81503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81504       };
81505     }
81506   }
81507
81508 }
81509
81510
81511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
81512   void * jresult ;
81513   Dali::Toolkit::TableView *result = 0 ;
81514
81515   {
81516     try {
81517       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
81518     } catch (std::out_of_range& e) {
81519       {
81520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81521       };
81522     } catch (std::exception& e) {
81523       {
81524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81525       };
81526     } catch (Dali::DaliException e) {
81527       {
81528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81529       };
81530     } catch (...) {
81531       {
81532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81533       };
81534     }
81535   }
81536
81537   jresult = (void *)result;
81538   return jresult;
81539 }
81540
81541
81542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
81543   void * jresult ;
81544   Dali::Toolkit::TableView *arg1 = 0 ;
81545   Dali::Toolkit::TableView *result = 0 ;
81546
81547   arg1 = (Dali::Toolkit::TableView *)jarg1;
81548   if (!arg1) {
81549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81550     return 0;
81551   }
81552   {
81553     try {
81554       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
81555     } catch (std::out_of_range& e) {
81556       {
81557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81558       };
81559     } catch (std::exception& e) {
81560       {
81561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81562       };
81563     } catch (Dali::DaliException e) {
81564       {
81565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81566       };
81567     } catch (...) {
81568       {
81569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81570       };
81571     }
81572   }
81573
81574   jresult = (void *)result;
81575   return jresult;
81576 }
81577
81578
81579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
81580   void * jresult ;
81581   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81582   Dali::Toolkit::TableView *arg2 = 0 ;
81583   Dali::Toolkit::TableView *result = 0 ;
81584
81585   arg1 = (Dali::Toolkit::TableView *)jarg1;
81586   arg2 = (Dali::Toolkit::TableView *)jarg2;
81587   if (!arg2) {
81588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81589     return 0;
81590   }
81591   {
81592     try {
81593       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
81594     } catch (std::out_of_range& e) {
81595       {
81596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81597       };
81598     } catch (std::exception& e) {
81599       {
81600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81601       };
81602     } catch (Dali::DaliException e) {
81603       {
81604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81605       };
81606     } catch (...) {
81607       {
81608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81609       };
81610     }
81611   }
81612
81613   jresult = (void *)result;
81614   return jresult;
81615 }
81616
81617
81618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
81619   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81620
81621   arg1 = (Dali::Toolkit::TableView *)jarg1;
81622   {
81623     try {
81624       delete arg1;
81625     } catch (std::out_of_range& e) {
81626       {
81627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81628       };
81629     } catch (std::exception& e) {
81630       {
81631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81632       };
81633     } catch (Dali::DaliException e) {
81634       {
81635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81636       };
81637     } catch (...) {
81638       {
81639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81640       };
81641     }
81642   }
81643
81644 }
81645
81646
81647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
81648   void * jresult ;
81649   unsigned int arg1 ;
81650   unsigned int arg2 ;
81651   Dali::Toolkit::TableView result;
81652
81653   arg1 = (unsigned int)jarg1;
81654   arg2 = (unsigned int)jarg2;
81655   {
81656     try {
81657       result = Dali::Toolkit::TableView::New(arg1,arg2);
81658     } catch (std::out_of_range& e) {
81659       {
81660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81661       };
81662     } catch (std::exception& e) {
81663       {
81664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81665       };
81666     } catch (Dali::DaliException e) {
81667       {
81668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81669       };
81670     } catch (...) {
81671       {
81672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81673       };
81674     }
81675   }
81676
81677   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81678   return jresult;
81679 }
81680
81681
81682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
81683   void * jresult ;
81684   Dali::BaseHandle arg1 ;
81685   Dali::BaseHandle *argp1 ;
81686   Dali::Toolkit::TableView result;
81687
81688   argp1 = (Dali::BaseHandle *)jarg1;
81689   if (!argp1) {
81690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81691     return 0;
81692   }
81693   arg1 = *argp1;
81694   {
81695     try {
81696       result = Dali::Toolkit::TableView::DownCast(arg1);
81697     } catch (std::out_of_range& e) {
81698       {
81699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81700       };
81701     } catch (std::exception& e) {
81702       {
81703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81704       };
81705     } catch (Dali::DaliException e) {
81706       {
81707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81708       };
81709     } catch (...) {
81710       {
81711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81712       };
81713     }
81714   }
81715
81716   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81717   return jresult;
81718 }
81719
81720
81721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
81722   unsigned int jresult ;
81723   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81724   Dali::Actor arg2 ;
81725   Dali::Toolkit::TableView::CellPosition arg3 ;
81726   Dali::Actor *argp2 ;
81727   Dali::Toolkit::TableView::CellPosition *argp3 ;
81728   bool result;
81729
81730   arg1 = (Dali::Toolkit::TableView *)jarg1;
81731   argp2 = (Dali::Actor *)jarg2;
81732   if (!argp2) {
81733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81734     return 0;
81735   }
81736   arg2 = *argp2;
81737   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81738   if (!argp3) {
81739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81740     return 0;
81741   }
81742   arg3 = *argp3;
81743   {
81744     try {
81745       result = (bool)(arg1)->AddChild(arg2,arg3);
81746     } catch (std::out_of_range& e) {
81747       {
81748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81749       };
81750     } catch (std::exception& e) {
81751       {
81752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81753       };
81754     } catch (Dali::DaliException e) {
81755       {
81756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81757       };
81758     } catch (...) {
81759       {
81760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81761       };
81762     }
81763   }
81764
81765   jresult = result;
81766   return jresult;
81767 }
81768
81769
81770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
81771   void * jresult ;
81772   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81773   Dali::Toolkit::TableView::CellPosition arg2 ;
81774   Dali::Toolkit::TableView::CellPosition *argp2 ;
81775   Dali::Actor result;
81776
81777   arg1 = (Dali::Toolkit::TableView *)jarg1;
81778   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81779   if (!argp2) {
81780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81781     return 0;
81782   }
81783   arg2 = *argp2;
81784   {
81785     try {
81786       result = (arg1)->GetChildAt(arg2);
81787     } catch (std::out_of_range& e) {
81788       {
81789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81790       };
81791     } catch (std::exception& e) {
81792       {
81793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81794       };
81795     } catch (Dali::DaliException e) {
81796       {
81797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81798       };
81799     } catch (...) {
81800       {
81801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81802       };
81803     }
81804   }
81805
81806   jresult = new Dali::Actor((const Dali::Actor &)result);
81807   return jresult;
81808 }
81809
81810
81811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
81812   void * jresult ;
81813   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81814   Dali::Toolkit::TableView::CellPosition arg2 ;
81815   Dali::Toolkit::TableView::CellPosition *argp2 ;
81816   Dali::Actor result;
81817
81818   arg1 = (Dali::Toolkit::TableView *)jarg1;
81819   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81820   if (!argp2) {
81821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81822     return 0;
81823   }
81824   arg2 = *argp2;
81825   {
81826     try {
81827       result = (arg1)->RemoveChildAt(arg2);
81828     } catch (std::out_of_range& e) {
81829       {
81830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81831       };
81832     } catch (std::exception& e) {
81833       {
81834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81835       };
81836     } catch (Dali::DaliException e) {
81837       {
81838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81839       };
81840     } catch (...) {
81841       {
81842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81843       };
81844     }
81845   }
81846
81847   jresult = new Dali::Actor((const Dali::Actor &)result);
81848   return jresult;
81849 }
81850
81851
81852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
81853   unsigned int jresult ;
81854   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81855   Dali::Actor arg2 ;
81856   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
81857   Dali::Actor *argp2 ;
81858   bool result;
81859
81860   arg1 = (Dali::Toolkit::TableView *)jarg1;
81861   argp2 = (Dali::Actor *)jarg2;
81862   if (!argp2) {
81863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81864     return 0;
81865   }
81866   arg2 = *argp2;
81867   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81868   if (!arg3) {
81869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
81870     return 0;
81871   }
81872   {
81873     try {
81874       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
81875     } catch (std::out_of_range& e) {
81876       {
81877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81878       };
81879     } catch (std::exception& e) {
81880       {
81881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81882       };
81883     } catch (Dali::DaliException e) {
81884       {
81885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81886       };
81887     } catch (...) {
81888       {
81889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81890       };
81891     }
81892   }
81893
81894   jresult = result;
81895   return jresult;
81896 }
81897
81898
81899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
81900   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81901   unsigned int arg2 ;
81902
81903   arg1 = (Dali::Toolkit::TableView *)jarg1;
81904   arg2 = (unsigned int)jarg2;
81905   {
81906     try {
81907       (arg1)->InsertRow(arg2);
81908     } catch (std::out_of_range& e) {
81909       {
81910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81911       };
81912     } catch (std::exception& e) {
81913       {
81914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81915       };
81916     } catch (Dali::DaliException e) {
81917       {
81918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81919       };
81920     } catch (...) {
81921       {
81922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81923       };
81924     }
81925   }
81926
81927 }
81928
81929
81930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
81931   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81932   unsigned int arg2 ;
81933
81934   arg1 = (Dali::Toolkit::TableView *)jarg1;
81935   arg2 = (unsigned int)jarg2;
81936   {
81937     try {
81938       (arg1)->DeleteRow(arg2);
81939     } catch (std::out_of_range& e) {
81940       {
81941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81942       };
81943     } catch (std::exception& e) {
81944       {
81945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81946       };
81947     } catch (Dali::DaliException e) {
81948       {
81949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81950       };
81951     } catch (...) {
81952       {
81953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81954       };
81955     }
81956   }
81957
81958 }
81959
81960
81961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81962   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81963   unsigned int arg2 ;
81964   std::vector< Dali::Actor > *arg3 = 0 ;
81965
81966   arg1 = (Dali::Toolkit::TableView *)jarg1;
81967   arg2 = (unsigned int)jarg2;
81968   arg3 = (std::vector< Dali::Actor > *)jarg3;
81969   if (!arg3) {
81970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81971     return ;
81972   }
81973   {
81974     try {
81975       (arg1)->DeleteRow(arg2,*arg3);
81976     } catch (std::out_of_range& e) {
81977       {
81978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81979       };
81980     } catch (std::exception& e) {
81981       {
81982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81983       };
81984     } catch (Dali::DaliException e) {
81985       {
81986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81987       };
81988     } catch (...) {
81989       {
81990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81991       };
81992     }
81993   }
81994
81995 }
81996
81997
81998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
81999   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82000   unsigned int arg2 ;
82001
82002   arg1 = (Dali::Toolkit::TableView *)jarg1;
82003   arg2 = (unsigned int)jarg2;
82004   {
82005     try {
82006       (arg1)->InsertColumn(arg2);
82007     } catch (std::out_of_range& e) {
82008       {
82009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82010       };
82011     } catch (std::exception& e) {
82012       {
82013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82014       };
82015     } catch (Dali::DaliException e) {
82016       {
82017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82018       };
82019     } catch (...) {
82020       {
82021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82022       };
82023     }
82024   }
82025
82026 }
82027
82028
82029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
82030   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82031   unsigned int arg2 ;
82032
82033   arg1 = (Dali::Toolkit::TableView *)jarg1;
82034   arg2 = (unsigned int)jarg2;
82035   {
82036     try {
82037       (arg1)->DeleteColumn(arg2);
82038     } catch (std::out_of_range& e) {
82039       {
82040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82041       };
82042     } catch (std::exception& e) {
82043       {
82044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82045       };
82046     } catch (Dali::DaliException e) {
82047       {
82048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82049       };
82050     } catch (...) {
82051       {
82052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82053       };
82054     }
82055   }
82056
82057 }
82058
82059
82060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82061   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82062   unsigned int arg2 ;
82063   std::vector< Dali::Actor > *arg3 = 0 ;
82064
82065   arg1 = (Dali::Toolkit::TableView *)jarg1;
82066   arg2 = (unsigned int)jarg2;
82067   arg3 = (std::vector< Dali::Actor > *)jarg3;
82068   if (!arg3) {
82069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82070     return ;
82071   }
82072   {
82073     try {
82074       (arg1)->DeleteColumn(arg2,*arg3);
82075     } catch (std::out_of_range& e) {
82076       {
82077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82078       };
82079     } catch (std::exception& e) {
82080       {
82081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82082       };
82083     } catch (Dali::DaliException e) {
82084       {
82085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82086       };
82087     } catch (...) {
82088       {
82089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82090       };
82091     }
82092   }
82093
82094 }
82095
82096
82097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82098   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82099   unsigned int arg2 ;
82100   unsigned int arg3 ;
82101
82102   arg1 = (Dali::Toolkit::TableView *)jarg1;
82103   arg2 = (unsigned int)jarg2;
82104   arg3 = (unsigned int)jarg3;
82105   {
82106     try {
82107       (arg1)->Resize(arg2,arg3);
82108     } catch (std::out_of_range& e) {
82109       {
82110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82111       };
82112     } catch (std::exception& e) {
82113       {
82114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82115       };
82116     } catch (Dali::DaliException e) {
82117       {
82118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82119       };
82120     } catch (...) {
82121       {
82122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82123       };
82124     }
82125   }
82126
82127 }
82128
82129
82130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82131   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82132   unsigned int arg2 ;
82133   unsigned int arg3 ;
82134   std::vector< Dali::Actor > *arg4 = 0 ;
82135
82136   arg1 = (Dali::Toolkit::TableView *)jarg1;
82137   arg2 = (unsigned int)jarg2;
82138   arg3 = (unsigned int)jarg3;
82139   arg4 = (std::vector< Dali::Actor > *)jarg4;
82140   if (!arg4) {
82141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82142     return ;
82143   }
82144   {
82145     try {
82146       (arg1)->Resize(arg2,arg3,*arg4);
82147     } catch (std::out_of_range& e) {
82148       {
82149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82150       };
82151     } catch (std::exception& e) {
82152       {
82153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82154       };
82155     } catch (Dali::DaliException e) {
82156       {
82157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82158       };
82159     } catch (...) {
82160       {
82161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82162       };
82163     }
82164   }
82165
82166 }
82167
82168
82169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
82170   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82171   Dali::Size arg2 ;
82172   Dali::Size *argp2 ;
82173
82174   arg1 = (Dali::Toolkit::TableView *)jarg1;
82175   argp2 = (Dali::Size *)jarg2;
82176   if (!argp2) {
82177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
82178     return ;
82179   }
82180   arg2 = *argp2;
82181   {
82182     try {
82183       (arg1)->SetCellPadding(arg2);
82184     } catch (std::out_of_range& e) {
82185       {
82186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82187       };
82188     } catch (std::exception& e) {
82189       {
82190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82191       };
82192     } catch (Dali::DaliException e) {
82193       {
82194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82195       };
82196     } catch (...) {
82197       {
82198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82199       };
82200     }
82201   }
82202
82203 }
82204
82205
82206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
82207   void * jresult ;
82208   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82209   Dali::Size result;
82210
82211   arg1 = (Dali::Toolkit::TableView *)jarg1;
82212   {
82213     try {
82214       result = (arg1)->GetCellPadding();
82215     } catch (std::out_of_range& e) {
82216       {
82217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82218       };
82219     } catch (std::exception& e) {
82220       {
82221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82222       };
82223     } catch (Dali::DaliException e) {
82224       {
82225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82226       };
82227     } catch (...) {
82228       {
82229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82230       };
82231     }
82232   }
82233
82234   jresult = new Dali::Size((const Dali::Size &)result);
82235   return jresult;
82236 }
82237
82238
82239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
82240   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82241   unsigned int arg2 ;
82242
82243   arg1 = (Dali::Toolkit::TableView *)jarg1;
82244   arg2 = (unsigned int)jarg2;
82245   {
82246     try {
82247       (arg1)->SetFitHeight(arg2);
82248     } catch (std::out_of_range& e) {
82249       {
82250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82251       };
82252     } catch (std::exception& e) {
82253       {
82254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82255       };
82256     } catch (Dali::DaliException e) {
82257       {
82258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82259       };
82260     } catch (...) {
82261       {
82262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82263       };
82264     }
82265   }
82266
82267 }
82268
82269
82270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
82271   unsigned int jresult ;
82272   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82273   unsigned int arg2 ;
82274   bool result;
82275
82276   arg1 = (Dali::Toolkit::TableView *)jarg1;
82277   arg2 = (unsigned int)jarg2;
82278   {
82279     try {
82280       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
82281     } catch (std::out_of_range& e) {
82282       {
82283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82284       };
82285     } catch (std::exception& e) {
82286       {
82287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82288       };
82289     } catch (Dali::DaliException e) {
82290       {
82291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82292       };
82293     } catch (...) {
82294       {
82295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82296       };
82297     }
82298   }
82299
82300   jresult = result;
82301   return jresult;
82302 }
82303
82304
82305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
82306   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82307   unsigned int arg2 ;
82308
82309   arg1 = (Dali::Toolkit::TableView *)jarg1;
82310   arg2 = (unsigned int)jarg2;
82311   {
82312     try {
82313       (arg1)->SetFitWidth(arg2);
82314     } catch (std::out_of_range& e) {
82315       {
82316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82317       };
82318     } catch (std::exception& e) {
82319       {
82320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82321       };
82322     } catch (Dali::DaliException e) {
82323       {
82324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82325       };
82326     } catch (...) {
82327       {
82328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82329       };
82330     }
82331   }
82332
82333 }
82334
82335
82336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
82337   unsigned int jresult ;
82338   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82339   unsigned int arg2 ;
82340   bool result;
82341
82342   arg1 = (Dali::Toolkit::TableView *)jarg1;
82343   arg2 = (unsigned int)jarg2;
82344   {
82345     try {
82346       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
82347     } catch (std::out_of_range& e) {
82348       {
82349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82350       };
82351     } catch (std::exception& e) {
82352       {
82353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82354       };
82355     } catch (Dali::DaliException e) {
82356       {
82357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82358       };
82359     } catch (...) {
82360       {
82361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82362       };
82363     }
82364   }
82365
82366   jresult = result;
82367   return jresult;
82368 }
82369
82370
82371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82372   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82373   unsigned int arg2 ;
82374   float arg3 ;
82375
82376   arg1 = (Dali::Toolkit::TableView *)jarg1;
82377   arg2 = (unsigned int)jarg2;
82378   arg3 = (float)jarg3;
82379   {
82380     try {
82381       (arg1)->SetFixedHeight(arg2,arg3);
82382     } catch (std::out_of_range& e) {
82383       {
82384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82385       };
82386     } catch (std::exception& e) {
82387       {
82388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82389       };
82390     } catch (Dali::DaliException e) {
82391       {
82392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82393       };
82394     } catch (...) {
82395       {
82396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82397       };
82398     }
82399   }
82400
82401 }
82402
82403
82404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
82405   float jresult ;
82406   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82407   unsigned int arg2 ;
82408   float result;
82409
82410   arg1 = (Dali::Toolkit::TableView *)jarg1;
82411   arg2 = (unsigned int)jarg2;
82412   {
82413     try {
82414       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
82415     } catch (std::out_of_range& e) {
82416       {
82417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82418       };
82419     } catch (std::exception& e) {
82420       {
82421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82422       };
82423     } catch (Dali::DaliException e) {
82424       {
82425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82426       };
82427     } catch (...) {
82428       {
82429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82430       };
82431     }
82432   }
82433
82434   jresult = result;
82435   return jresult;
82436 }
82437
82438
82439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82440   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82441   unsigned int arg2 ;
82442   float arg3 ;
82443
82444   arg1 = (Dali::Toolkit::TableView *)jarg1;
82445   arg2 = (unsigned int)jarg2;
82446   arg3 = (float)jarg3;
82447   {
82448     try {
82449       (arg1)->SetRelativeHeight(arg2,arg3);
82450     } catch (std::out_of_range& e) {
82451       {
82452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82453       };
82454     } catch (std::exception& e) {
82455       {
82456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82457       };
82458     } catch (Dali::DaliException e) {
82459       {
82460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82461       };
82462     } catch (...) {
82463       {
82464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82465       };
82466     }
82467   }
82468
82469 }
82470
82471
82472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
82473   float jresult ;
82474   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82475   unsigned int arg2 ;
82476   float result;
82477
82478   arg1 = (Dali::Toolkit::TableView *)jarg1;
82479   arg2 = (unsigned int)jarg2;
82480   {
82481     try {
82482       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
82483     } catch (std::out_of_range& e) {
82484       {
82485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82486       };
82487     } catch (std::exception& e) {
82488       {
82489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82490       };
82491     } catch (Dali::DaliException e) {
82492       {
82493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82494       };
82495     } catch (...) {
82496       {
82497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82498       };
82499     }
82500   }
82501
82502   jresult = result;
82503   return jresult;
82504 }
82505
82506
82507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82508   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82509   unsigned int arg2 ;
82510   float arg3 ;
82511
82512   arg1 = (Dali::Toolkit::TableView *)jarg1;
82513   arg2 = (unsigned int)jarg2;
82514   arg3 = (float)jarg3;
82515   {
82516     try {
82517       (arg1)->SetFixedWidth(arg2,arg3);
82518     } catch (std::out_of_range& e) {
82519       {
82520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82521       };
82522     } catch (std::exception& e) {
82523       {
82524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82525       };
82526     } catch (Dali::DaliException e) {
82527       {
82528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82529       };
82530     } catch (...) {
82531       {
82532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82533       };
82534     }
82535   }
82536
82537 }
82538
82539
82540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
82541   float jresult ;
82542   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82543   unsigned int arg2 ;
82544   float result;
82545
82546   arg1 = (Dali::Toolkit::TableView *)jarg1;
82547   arg2 = (unsigned int)jarg2;
82548   {
82549     try {
82550       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
82551     } catch (std::out_of_range& e) {
82552       {
82553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82554       };
82555     } catch (std::exception& e) {
82556       {
82557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82558       };
82559     } catch (Dali::DaliException e) {
82560       {
82561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82562       };
82563     } catch (...) {
82564       {
82565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82566       };
82567     }
82568   }
82569
82570   jresult = result;
82571   return jresult;
82572 }
82573
82574
82575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82576   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82577   unsigned int arg2 ;
82578   float arg3 ;
82579
82580   arg1 = (Dali::Toolkit::TableView *)jarg1;
82581   arg2 = (unsigned int)jarg2;
82582   arg3 = (float)jarg3;
82583   {
82584     try {
82585       (arg1)->SetRelativeWidth(arg2,arg3);
82586     } catch (std::out_of_range& e) {
82587       {
82588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82589       };
82590     } catch (std::exception& e) {
82591       {
82592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82593       };
82594     } catch (Dali::DaliException e) {
82595       {
82596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82597       };
82598     } catch (...) {
82599       {
82600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82601       };
82602     }
82603   }
82604
82605 }
82606
82607
82608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
82609   float jresult ;
82610   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82611   unsigned int arg2 ;
82612   float result;
82613
82614   arg1 = (Dali::Toolkit::TableView *)jarg1;
82615   arg2 = (unsigned int)jarg2;
82616   {
82617     try {
82618       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
82619     } catch (std::out_of_range& e) {
82620       {
82621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82622       };
82623     } catch (std::exception& e) {
82624       {
82625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82626       };
82627     } catch (Dali::DaliException e) {
82628       {
82629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82630       };
82631     } catch (...) {
82632       {
82633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82634       };
82635     }
82636   }
82637
82638   jresult = result;
82639   return jresult;
82640 }
82641
82642
82643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
82644   unsigned int jresult ;
82645   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82646   unsigned int result;
82647
82648   arg1 = (Dali::Toolkit::TableView *)jarg1;
82649   {
82650     try {
82651       result = (unsigned int)(arg1)->GetRows();
82652     } catch (std::out_of_range& e) {
82653       {
82654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82655       };
82656     } catch (std::exception& e) {
82657       {
82658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82659       };
82660     } catch (Dali::DaliException e) {
82661       {
82662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82663       };
82664     } catch (...) {
82665       {
82666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82667       };
82668     }
82669   }
82670
82671   jresult = result;
82672   return jresult;
82673 }
82674
82675
82676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
82677   unsigned int jresult ;
82678   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82679   unsigned int result;
82680
82681   arg1 = (Dali::Toolkit::TableView *)jarg1;
82682   {
82683     try {
82684       result = (unsigned int)(arg1)->GetColumns();
82685     } catch (std::out_of_range& e) {
82686       {
82687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82688       };
82689     } catch (std::exception& e) {
82690       {
82691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82692       };
82693     } catch (Dali::DaliException e) {
82694       {
82695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82696       };
82697     } catch (...) {
82698       {
82699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82700       };
82701     }
82702   }
82703
82704   jresult = result;
82705   return jresult;
82706 }
82707
82708
82709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
82710   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82711   Dali::Toolkit::TableView::CellPosition arg2 ;
82712   Dali::HorizontalAlignment::Type arg3 ;
82713   Dali::VerticalAlignment::Type arg4 ;
82714   Dali::Toolkit::TableView::CellPosition *argp2 ;
82715
82716   arg1 = (Dali::Toolkit::TableView *)jarg1;
82717   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82718   if (!argp2) {
82719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82720     return ;
82721   }
82722   arg2 = *argp2;
82723   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
82724   arg4 = (Dali::VerticalAlignment::Type)jarg4;
82725   {
82726     try {
82727       (arg1)->SetCellAlignment(arg2,arg3,arg4);
82728     } catch (std::out_of_range& e) {
82729       {
82730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82731       };
82732     } catch (std::exception& e) {
82733       {
82734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82735       };
82736     } catch (Dali::DaliException e) {
82737       {
82738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82739       };
82740     } catch (...) {
82741       {
82742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82743       };
82744     }
82745   }
82746
82747 }
82748
82749
82750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
82751   unsigned int jresult ;
82752   unsigned int result;
82753
82754   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
82755   jresult = result;
82756   return jresult;
82757 }
82758
82759
82760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
82761   int jresult ;
82762   int result;
82763
82764   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
82765   jresult = (int)result;
82766   return jresult;
82767 }
82768
82769
82770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
82771   int jresult ;
82772   int result;
82773
82774   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
82775   jresult = (int)result;
82776   return jresult;
82777 }
82778
82779
82780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
82781   int jresult ;
82782   int result;
82783
82784   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
82785   jresult = (int)result;
82786   return jresult;
82787 }
82788
82789
82790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
82791   int jresult ;
82792   int result;
82793
82794   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
82795   jresult = (int)result;
82796   return jresult;
82797 }
82798
82799
82800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
82801   int jresult ;
82802   int result;
82803
82804   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
82805   jresult = (int)result;
82806   return jresult;
82807 }
82808
82809
82810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
82811   int jresult ;
82812   int result;
82813
82814   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
82815   jresult = (int)result;
82816   return jresult;
82817 }
82818
82819
82820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
82821   int jresult ;
82822   int result;
82823
82824   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
82825   jresult = (int)result;
82826   return jresult;
82827 }
82828
82829
82830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
82831   int jresult ;
82832   int result;
82833
82834   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
82835   jresult = (int)result;
82836   return jresult;
82837 }
82838
82839
82840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
82841   int jresult ;
82842   int result;
82843
82844   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
82845   jresult = (int)result;
82846   return jresult;
82847 }
82848
82849
82850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
82851   int jresult ;
82852   int result;
82853
82854   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
82855   jresult = (int)result;
82856   return jresult;
82857 }
82858
82859
82860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
82861   int jresult ;
82862   int result;
82863
82864   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
82865   jresult = (int)result;
82866   return jresult;
82867 }
82868
82869
82870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
82871   int jresult ;
82872   int result;
82873
82874   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
82875   jresult = (int)result;
82876   return jresult;
82877 }
82878
82879
82880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
82881   int jresult ;
82882   int result;
82883
82884   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
82885   jresult = (int)result;
82886   return jresult;
82887 }
82888
82889
82890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
82891   int jresult ;
82892   int result;
82893
82894   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
82895   jresult = (int)result;
82896   return jresult;
82897 }
82898
82899
82900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
82901   int jresult ;
82902   int result;
82903
82904   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
82905   jresult = (int)result;
82906   return jresult;
82907 }
82908
82909
82910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
82911   int jresult ;
82912   int result;
82913
82914   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
82915   jresult = (int)result;
82916   return jresult;
82917 }
82918
82919
82920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
82921   int jresult ;
82922   int result;
82923
82924   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
82925   jresult = (int)result;
82926   return jresult;
82927 }
82928
82929
82930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
82931   int jresult ;
82932   int result;
82933
82934   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
82935   jresult = (int)result;
82936   return jresult;
82937 }
82938
82939
82940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
82941   int jresult ;
82942   int result;
82943
82944   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
82945   jresult = (int)result;
82946   return jresult;
82947 }
82948
82949
82950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
82951   void * jresult ;
82952   Dali::Toolkit::TextLabel::Property *result = 0 ;
82953
82954   {
82955     try {
82956       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
82957     } catch (std::out_of_range& e) {
82958       {
82959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82960       };
82961     } catch (std::exception& e) {
82962       {
82963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82964       };
82965     } catch (Dali::DaliException e) {
82966       {
82967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82968       };
82969     } catch (...) {
82970       {
82971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82972       };
82973     }
82974   }
82975
82976   jresult = (void *)result;
82977   return jresult;
82978 }
82979
82980
82981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
82982   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
82983
82984   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
82985   {
82986     try {
82987       delete arg1;
82988     } catch (std::out_of_range& e) {
82989       {
82990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82991       };
82992     } catch (std::exception& e) {
82993       {
82994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82995       };
82996     } catch (Dali::DaliException e) {
82997       {
82998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82999       };
83000     } catch (...) {
83001       {
83002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83003       };
83004     }
83005   }
83006
83007 }
83008
83009
83010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
83011   void * jresult ;
83012   Dali::Toolkit::TextLabel result;
83013
83014   {
83015     try {
83016       result = Dali::Toolkit::TextLabel::New();
83017     } catch (std::out_of_range& e) {
83018       {
83019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83020       };
83021     } catch (std::exception& e) {
83022       {
83023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83024       };
83025     } catch (Dali::DaliException e) {
83026       {
83027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83028       };
83029     } catch (...) {
83030       {
83031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83032       };
83033     }
83034   }
83035
83036   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83037   return jresult;
83038 }
83039
83040
83041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
83042   void * jresult ;
83043   std::string *arg1 = 0 ;
83044   Dali::Toolkit::TextLabel result;
83045
83046   if (!jarg1) {
83047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83048     return 0;
83049   }
83050   std::string arg1_str(jarg1);
83051   arg1 = &arg1_str;
83052   {
83053     try {
83054       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
83055     } catch (std::out_of_range& e) {
83056       {
83057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83058       };
83059     } catch (std::exception& e) {
83060       {
83061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83062       };
83063     } catch (Dali::DaliException e) {
83064       {
83065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83066       };
83067     } catch (...) {
83068       {
83069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83070       };
83071     }
83072   }
83073
83074   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83075
83076   //argout typemap for const std::string&
83077
83078   return jresult;
83079 }
83080
83081
83082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83083   void * jresult ;
83084   Dali::Toolkit::TextLabel *result = 0 ;
83085
83086   {
83087     try {
83088       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83089     } catch (std::out_of_range& e) {
83090       {
83091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83092       };
83093     } catch (std::exception& e) {
83094       {
83095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83096       };
83097     } catch (Dali::DaliException e) {
83098       {
83099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83100       };
83101     } catch (...) {
83102       {
83103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83104       };
83105     }
83106   }
83107
83108   jresult = (void *)result;
83109   return jresult;
83110 }
83111
83112
83113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83114   void * jresult ;
83115   Dali::Toolkit::TextLabel *arg1 = 0 ;
83116   Dali::Toolkit::TextLabel *result = 0 ;
83117
83118   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83119   if (!arg1) {
83120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83121     return 0;
83122   }
83123   {
83124     try {
83125       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83126     } catch (std::out_of_range& e) {
83127       {
83128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83129       };
83130     } catch (std::exception& e) {
83131       {
83132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83133       };
83134     } catch (Dali::DaliException e) {
83135       {
83136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83137       };
83138     } catch (...) {
83139       {
83140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83141       };
83142     }
83143   }
83144
83145   jresult = (void *)result;
83146   return jresult;
83147 }
83148
83149
83150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
83151   void * jresult ;
83152   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83153   Dali::Toolkit::TextLabel *arg2 = 0 ;
83154   Dali::Toolkit::TextLabel *result = 0 ;
83155
83156   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83157   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
83158   if (!arg2) {
83159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83160     return 0;
83161   }
83162   {
83163     try {
83164       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
83165     } catch (std::out_of_range& e) {
83166       {
83167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83168       };
83169     } catch (std::exception& e) {
83170       {
83171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83172       };
83173     } catch (Dali::DaliException e) {
83174       {
83175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83176       };
83177     } catch (...) {
83178       {
83179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83180       };
83181     }
83182   }
83183
83184   jresult = (void *)result;
83185   return jresult;
83186 }
83187
83188
83189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
83190   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83191
83192   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83193   {
83194     try {
83195       delete arg1;
83196     } catch (std::out_of_range& e) {
83197       {
83198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83199       };
83200     } catch (std::exception& e) {
83201       {
83202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83203       };
83204     } catch (Dali::DaliException e) {
83205       {
83206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83207       };
83208     } catch (...) {
83209       {
83210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83211       };
83212     }
83213   }
83214
83215 }
83216
83217
83218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
83219   void * jresult ;
83220   Dali::BaseHandle arg1 ;
83221   Dali::BaseHandle *argp1 ;
83222   Dali::Toolkit::TextLabel result;
83223
83224   argp1 = (Dali::BaseHandle *)jarg1;
83225   if (!argp1) {
83226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83227     return 0;
83228   }
83229   arg1 = *argp1;
83230   {
83231     try {
83232       result = Dali::Toolkit::TextLabel::DownCast(arg1);
83233     } catch (std::out_of_range& e) {
83234       {
83235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83236       };
83237     } catch (std::exception& e) {
83238       {
83239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83240       };
83241     } catch (Dali::DaliException e) {
83242       {
83243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83244       };
83245     } catch (...) {
83246       {
83247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83248       };
83249     }
83250   }
83251
83252   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83253   return jresult;
83254 }
83255
83256
83257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
83258   void * jresult ;
83259   Dali::Toolkit::AccessibilityManager *result = 0 ;
83260
83261   {
83262     try {
83263       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
83264     } catch (std::out_of_range& e) {
83265       {
83266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83267       };
83268     } catch (std::exception& e) {
83269       {
83270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83271       };
83272     } catch (Dali::DaliException e) {
83273       {
83274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83275       };
83276     } catch (...) {
83277       {
83278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83279       };
83280     }
83281   }
83282
83283   jresult = (void *)result;
83284   return jresult;
83285 }
83286
83287
83288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
83289   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83290
83291   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83292   {
83293     try {
83294       delete arg1;
83295     } catch (std::out_of_range& e) {
83296       {
83297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83298       };
83299     } catch (std::exception& e) {
83300       {
83301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83302       };
83303     } catch (Dali::DaliException e) {
83304       {
83305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83306       };
83307     } catch (...) {
83308       {
83309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83310       };
83311     }
83312   }
83313
83314 }
83315
83316
83317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
83318   void * jresult ;
83319   Dali::Toolkit::AccessibilityManager result;
83320
83321   {
83322     try {
83323       result = Dali::Toolkit::AccessibilityManager::Get();
83324     } catch (std::out_of_range& e) {
83325       {
83326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83327       };
83328     } catch (std::exception& e) {
83329       {
83330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83331       };
83332     } catch (Dali::DaliException e) {
83333       {
83334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83335       };
83336     } catch (...) {
83337       {
83338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83339       };
83340     }
83341   }
83342
83343   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
83344   return jresult;
83345 }
83346
83347
83348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
83349   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83350   Dali::Actor arg2 ;
83351   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83352   std::string *arg4 = 0 ;
83353   Dali::Actor *argp2 ;
83354
83355   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83356   argp2 = (Dali::Actor *)jarg2;
83357   if (!argp2) {
83358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83359     return ;
83360   }
83361   arg2 = *argp2;
83362   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83363   if (!jarg4) {
83364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83365     return ;
83366   }
83367   std::string arg4_str(jarg4);
83368   arg4 = &arg4_str;
83369   {
83370     try {
83371       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
83372     } catch (std::out_of_range& e) {
83373       {
83374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83375       };
83376     } catch (std::exception& e) {
83377       {
83378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83379       };
83380     } catch (Dali::DaliException e) {
83381       {
83382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83383       };
83384     } catch (...) {
83385       {
83386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83387       };
83388     }
83389   }
83390
83391
83392   //argout typemap for const std::string&
83393
83394 }
83395
83396
83397 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
83398   char * jresult ;
83399   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83400   Dali::Actor arg2 ;
83401   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83402   Dali::Actor *argp2 ;
83403   std::string result;
83404
83405   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83406   argp2 = (Dali::Actor *)jarg2;
83407   if (!argp2) {
83408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83409     return 0;
83410   }
83411   arg2 = *argp2;
83412   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83413   {
83414     try {
83415       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
83416     } catch (std::out_of_range& e) {
83417       {
83418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83419       };
83420     } catch (std::exception& e) {
83421       {
83422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83423       };
83424     } catch (Dali::DaliException e) {
83425       {
83426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83427       };
83428     } catch (...) {
83429       {
83430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83431       };
83432     }
83433   }
83434
83435   jresult = SWIG_csharp_string_callback((&result)->c_str());
83436   return jresult;
83437 }
83438
83439
83440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
83441   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83442   Dali::Actor arg2 ;
83443   unsigned int arg3 ;
83444   Dali::Actor *argp2 ;
83445
83446   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83447   argp2 = (Dali::Actor *)jarg2;
83448   if (!argp2) {
83449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83450     return ;
83451   }
83452   arg2 = *argp2;
83453   arg3 = (unsigned int)jarg3;
83454   {
83455     try {
83456       (arg1)->SetFocusOrder(arg2,arg3);
83457     } catch (std::out_of_range& e) {
83458       {
83459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83460       };
83461     } catch (std::exception& e) {
83462       {
83463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83464       };
83465     } catch (Dali::DaliException e) {
83466       {
83467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83468       };
83469     } catch (...) {
83470       {
83471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83472       };
83473     }
83474   }
83475
83476 }
83477
83478
83479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
83480   unsigned int jresult ;
83481   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83482   Dali::Actor arg2 ;
83483   Dali::Actor *argp2 ;
83484   unsigned int result;
83485
83486   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83487   argp2 = (Dali::Actor *)jarg2;
83488   if (!argp2) {
83489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83490     return 0;
83491   }
83492   arg2 = *argp2;
83493   {
83494     try {
83495       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
83496     } catch (std::out_of_range& e) {
83497       {
83498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83499       };
83500     } catch (std::exception& e) {
83501       {
83502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83503       };
83504     } catch (Dali::DaliException e) {
83505       {
83506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83507       };
83508     } catch (...) {
83509       {
83510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83511       };
83512     }
83513   }
83514
83515   jresult = result;
83516   return jresult;
83517 }
83518
83519
83520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
83521   unsigned int jresult ;
83522   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83523   unsigned int result;
83524
83525   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83526   {
83527     try {
83528       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
83529     } catch (std::out_of_range& e) {
83530       {
83531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83532       };
83533     } catch (std::exception& e) {
83534       {
83535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83536       };
83537     } catch (Dali::DaliException e) {
83538       {
83539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83540       };
83541     } catch (...) {
83542       {
83543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83544       };
83545     }
83546   }
83547
83548   jresult = result;
83549   return jresult;
83550 }
83551
83552
83553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
83554   void * jresult ;
83555   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83556   unsigned int arg2 ;
83557   Dali::Actor result;
83558
83559   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83560   arg2 = (unsigned int)jarg2;
83561   {
83562     try {
83563       result = (arg1)->GetActorByFocusOrder(arg2);
83564     } catch (std::out_of_range& e) {
83565       {
83566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83567       };
83568     } catch (std::exception& e) {
83569       {
83570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83571       };
83572     } catch (Dali::DaliException e) {
83573       {
83574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83575       };
83576     } catch (...) {
83577       {
83578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83579       };
83580     }
83581   }
83582
83583   jresult = new Dali::Actor((const Dali::Actor &)result);
83584   return jresult;
83585 }
83586
83587
83588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
83589   unsigned int jresult ;
83590   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83591   Dali::Actor arg2 ;
83592   Dali::Actor *argp2 ;
83593   bool result;
83594
83595   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83596   argp2 = (Dali::Actor *)jarg2;
83597   if (!argp2) {
83598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83599     return 0;
83600   }
83601   arg2 = *argp2;
83602   {
83603     try {
83604       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
83605     } catch (std::out_of_range& e) {
83606       {
83607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83608       };
83609     } catch (std::exception& e) {
83610       {
83611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83612       };
83613     } catch (Dali::DaliException e) {
83614       {
83615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83616       };
83617     } catch (...) {
83618       {
83619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83620       };
83621     }
83622   }
83623
83624   jresult = result;
83625   return jresult;
83626 }
83627
83628
83629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
83630   void * jresult ;
83631   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83632   Dali::Actor result;
83633
83634   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83635   {
83636     try {
83637       result = (arg1)->GetCurrentFocusActor();
83638     } catch (std::out_of_range& e) {
83639       {
83640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83641       };
83642     } catch (std::exception& e) {
83643       {
83644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83645       };
83646     } catch (Dali::DaliException e) {
83647       {
83648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83649       };
83650     } catch (...) {
83651       {
83652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83653       };
83654     }
83655   }
83656
83657   jresult = new Dali::Actor((const Dali::Actor &)result);
83658   return jresult;
83659 }
83660
83661
83662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
83663   void * jresult ;
83664   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83665   Dali::Actor result;
83666
83667   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83668   {
83669     try {
83670       result = (arg1)->GetCurrentFocusGroup();
83671     } catch (std::out_of_range& e) {
83672       {
83673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83674       };
83675     } catch (std::exception& e) {
83676       {
83677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83678       };
83679     } catch (Dali::DaliException e) {
83680       {
83681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83682       };
83683     } catch (...) {
83684       {
83685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83686       };
83687     }
83688   }
83689
83690   jresult = new Dali::Actor((const Dali::Actor &)result);
83691   return jresult;
83692 }
83693
83694
83695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
83696   unsigned int jresult ;
83697   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83698   unsigned int result;
83699
83700   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83701   {
83702     try {
83703       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
83704     } catch (std::out_of_range& e) {
83705       {
83706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83707       };
83708     } catch (std::exception& e) {
83709       {
83710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83711       };
83712     } catch (Dali::DaliException e) {
83713       {
83714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83715       };
83716     } catch (...) {
83717       {
83718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83719       };
83720     }
83721   }
83722
83723   jresult = result;
83724   return jresult;
83725 }
83726
83727
83728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
83729   unsigned int jresult ;
83730   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83731   bool result;
83732
83733   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83734   {
83735     try {
83736       result = (bool)(arg1)->MoveFocusForward();
83737     } catch (std::out_of_range& e) {
83738       {
83739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83740       };
83741     } catch (std::exception& e) {
83742       {
83743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83744       };
83745     } catch (Dali::DaliException e) {
83746       {
83747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83748       };
83749     } catch (...) {
83750       {
83751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83752       };
83753     }
83754   }
83755
83756   jresult = result;
83757   return jresult;
83758 }
83759
83760
83761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
83762   unsigned int jresult ;
83763   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83764   bool result;
83765
83766   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83767   {
83768     try {
83769       result = (bool)(arg1)->MoveFocusBackward();
83770     } catch (std::out_of_range& e) {
83771       {
83772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83773       };
83774     } catch (std::exception& e) {
83775       {
83776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83777       };
83778     } catch (Dali::DaliException e) {
83779       {
83780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83781       };
83782     } catch (...) {
83783       {
83784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83785       };
83786     }
83787   }
83788
83789   jresult = result;
83790   return jresult;
83791 }
83792
83793
83794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
83795   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83796
83797   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83798   {
83799     try {
83800       (arg1)->ClearFocus();
83801     } catch (std::out_of_range& e) {
83802       {
83803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83804       };
83805     } catch (std::exception& e) {
83806       {
83807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83808       };
83809     } catch (Dali::DaliException e) {
83810       {
83811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83812       };
83813     } catch (...) {
83814       {
83815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83816       };
83817     }
83818   }
83819
83820 }
83821
83822
83823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
83824   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83825
83826   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83827   {
83828     try {
83829       (arg1)->Reset();
83830     } catch (std::out_of_range& e) {
83831       {
83832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83833       };
83834     } catch (std::exception& e) {
83835       {
83836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83837       };
83838     } catch (Dali::DaliException e) {
83839       {
83840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83841       };
83842     } catch (...) {
83843       {
83844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83845       };
83846     }
83847   }
83848
83849 }
83850
83851
83852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
83853   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83854   Dali::Actor arg2 ;
83855   bool arg3 ;
83856   Dali::Actor *argp2 ;
83857
83858   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83859   argp2 = (Dali::Actor *)jarg2;
83860   if (!argp2) {
83861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83862     return ;
83863   }
83864   arg2 = *argp2;
83865   arg3 = jarg3 ? true : false;
83866   {
83867     try {
83868       (arg1)->SetFocusGroup(arg2,arg3);
83869     } catch (std::out_of_range& e) {
83870       {
83871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83872       };
83873     } catch (std::exception& e) {
83874       {
83875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83876       };
83877     } catch (Dali::DaliException e) {
83878       {
83879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83880       };
83881     } catch (...) {
83882       {
83883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83884       };
83885     }
83886   }
83887
83888 }
83889
83890
83891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
83892   unsigned int jresult ;
83893   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83894   Dali::Actor arg2 ;
83895   Dali::Actor *argp2 ;
83896   bool result;
83897
83898   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83899   argp2 = (Dali::Actor *)jarg2;
83900   if (!argp2) {
83901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83902     return 0;
83903   }
83904   arg2 = *argp2;
83905   {
83906     try {
83907       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
83908     } catch (std::out_of_range& e) {
83909       {
83910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83911       };
83912     } catch (std::exception& e) {
83913       {
83914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83915       };
83916     } catch (Dali::DaliException e) {
83917       {
83918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83919       };
83920     } catch (...) {
83921       {
83922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83923       };
83924     }
83925   }
83926
83927   jresult = result;
83928   return jresult;
83929 }
83930
83931
83932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
83933   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83934   bool arg2 ;
83935
83936   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83937   arg2 = jarg2 ? true : false;
83938   {
83939     try {
83940       (arg1)->SetGroupMode(arg2);
83941     } catch (std::out_of_range& e) {
83942       {
83943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83944       };
83945     } catch (std::exception& e) {
83946       {
83947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83948       };
83949     } catch (Dali::DaliException e) {
83950       {
83951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83952       };
83953     } catch (...) {
83954       {
83955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83956       };
83957     }
83958   }
83959
83960 }
83961
83962
83963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
83964   unsigned int jresult ;
83965   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83966   bool result;
83967
83968   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83969   {
83970     try {
83971       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
83972     } catch (std::out_of_range& e) {
83973       {
83974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83975       };
83976     } catch (std::exception& e) {
83977       {
83978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83979       };
83980     } catch (Dali::DaliException e) {
83981       {
83982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83983       };
83984     } catch (...) {
83985       {
83986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83987       };
83988     }
83989   }
83990
83991   jresult = result;
83992   return jresult;
83993 }
83994
83995
83996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
83997   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83998   bool arg2 ;
83999
84000   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84001   arg2 = jarg2 ? true : false;
84002   {
84003     try {
84004       (arg1)->SetWrapMode(arg2);
84005     } catch (std::out_of_range& e) {
84006       {
84007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84008       };
84009     } catch (std::exception& e) {
84010       {
84011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84012       };
84013     } catch (Dali::DaliException e) {
84014       {
84015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84016       };
84017     } catch (...) {
84018       {
84019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84020       };
84021     }
84022   }
84023
84024 }
84025
84026
84027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
84028   unsigned int jresult ;
84029   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84030   bool result;
84031
84032   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84033   {
84034     try {
84035       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
84036     } catch (std::out_of_range& e) {
84037       {
84038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84039       };
84040     } catch (std::exception& e) {
84041       {
84042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84043       };
84044     } catch (Dali::DaliException e) {
84045       {
84046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84047       };
84048     } catch (...) {
84049       {
84050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84051       };
84052     }
84053   }
84054
84055   jresult = result;
84056   return jresult;
84057 }
84058
84059
84060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
84061   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84062   Dali::Actor arg2 ;
84063   Dali::Actor *argp2 ;
84064
84065   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84066   argp2 = (Dali::Actor *)jarg2;
84067   if (!argp2) {
84068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84069     return ;
84070   }
84071   arg2 = *argp2;
84072   {
84073     try {
84074       (arg1)->SetFocusIndicatorActor(arg2);
84075     } catch (std::out_of_range& e) {
84076       {
84077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84078       };
84079     } catch (std::exception& e) {
84080       {
84081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84082       };
84083     } catch (Dali::DaliException e) {
84084       {
84085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84086       };
84087     } catch (...) {
84088       {
84089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84090       };
84091     }
84092   }
84093
84094 }
84095
84096
84097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84098   void * jresult ;
84099   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84100   Dali::Actor result;
84101
84102   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84103   {
84104     try {
84105       result = (arg1)->GetFocusIndicatorActor();
84106     } catch (std::out_of_range& e) {
84107       {
84108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84109       };
84110     } catch (std::exception& e) {
84111       {
84112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84113       };
84114     } catch (Dali::DaliException e) {
84115       {
84116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84117       };
84118     } catch (...) {
84119       {
84120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84121       };
84122     }
84123   }
84124
84125   jresult = new Dali::Actor((const Dali::Actor &)result);
84126   return jresult;
84127 }
84128
84129
84130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84131   void * jresult ;
84132   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84133   Dali::Actor arg2 ;
84134   Dali::Actor *argp2 ;
84135   Dali::Actor result;
84136
84137   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84138   argp2 = (Dali::Actor *)jarg2;
84139   if (!argp2) {
84140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84141     return 0;
84142   }
84143   arg2 = *argp2;
84144   {
84145     try {
84146       result = (arg1)->GetFocusGroup(arg2);
84147     } catch (std::out_of_range& e) {
84148       {
84149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84150       };
84151     } catch (std::exception& e) {
84152       {
84153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84154       };
84155     } catch (Dali::DaliException e) {
84156       {
84157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84158       };
84159     } catch (...) {
84160       {
84161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84162       };
84163     }
84164   }
84165
84166   jresult = new Dali::Actor((const Dali::Actor &)result);
84167   return jresult;
84168 }
84169
84170
84171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
84172   void * jresult ;
84173   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84174   Dali::Vector2 result;
84175
84176   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84177   {
84178     try {
84179       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
84180     } catch (std::out_of_range& e) {
84181       {
84182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84183       };
84184     } catch (std::exception& e) {
84185       {
84186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84187       };
84188     } catch (Dali::DaliException e) {
84189       {
84190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84191       };
84192     } catch (...) {
84193       {
84194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84195       };
84196     }
84197   }
84198
84199   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
84200   return jresult;
84201 }
84202
84203
84204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
84205   void * jresult ;
84206   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84207   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
84208
84209   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84210   {
84211     try {
84212       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
84213     } catch (std::out_of_range& e) {
84214       {
84215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84216       };
84217     } catch (std::exception& e) {
84218       {
84219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84220       };
84221     } catch (Dali::DaliException e) {
84222       {
84223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84224       };
84225     } catch (...) {
84226       {
84227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84228       };
84229     }
84230   }
84231
84232   jresult = (void *)result;
84233   return jresult;
84234 }
84235
84236
84237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
84238   void * jresult ;
84239   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84240   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
84241
84242   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84243   {
84244     try {
84245       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
84246     } catch (std::out_of_range& e) {
84247       {
84248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84249       };
84250     } catch (std::exception& e) {
84251       {
84252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84253       };
84254     } catch (Dali::DaliException e) {
84255       {
84256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84257       };
84258     } catch (...) {
84259       {
84260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84261       };
84262     }
84263   }
84264
84265   jresult = (void *)result;
84266   return jresult;
84267 }
84268
84269
84270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
84271   void * jresult ;
84272   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84273   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
84274
84275   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84276   {
84277     try {
84278       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
84279     } catch (std::out_of_range& e) {
84280       {
84281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84282       };
84283     } catch (std::exception& e) {
84284       {
84285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84286       };
84287     } catch (Dali::DaliException e) {
84288       {
84289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84290       };
84291     } catch (...) {
84292       {
84293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84294       };
84295     }
84296   }
84297
84298   jresult = (void *)result;
84299   return jresult;
84300 }
84301
84302
84303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
84304   void * jresult ;
84305   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84306   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84307
84308   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84309   {
84310     try {
84311       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
84312     } catch (std::out_of_range& e) {
84313       {
84314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84315       };
84316     } catch (std::exception& e) {
84317       {
84318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84319       };
84320     } catch (Dali::DaliException e) {
84321       {
84322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84323       };
84324     } catch (...) {
84325       {
84326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84327       };
84328     }
84329   }
84330
84331   jresult = (void *)result;
84332   return jresult;
84333 }
84334
84335
84336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
84337   void * jresult ;
84338   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84339   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84340
84341   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84342   {
84343     try {
84344       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
84345     } catch (std::out_of_range& e) {
84346       {
84347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84348       };
84349     } catch (std::exception& e) {
84350       {
84351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84352       };
84353     } catch (Dali::DaliException e) {
84354       {
84355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84356       };
84357     } catch (...) {
84358       {
84359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84360       };
84361     }
84362   }
84363
84364   jresult = (void *)result;
84365   return jresult;
84366 }
84367
84368
84369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
84370   void * jresult ;
84371   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84372   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84373
84374   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84375   {
84376     try {
84377       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
84378     } catch (std::out_of_range& e) {
84379       {
84380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84381       };
84382     } catch (std::exception& e) {
84383       {
84384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84385       };
84386     } catch (Dali::DaliException e) {
84387       {
84388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84389       };
84390     } catch (...) {
84391       {
84392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84393       };
84394     }
84395   }
84396
84397   jresult = (void *)result;
84398   return jresult;
84399 }
84400
84401
84402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
84403   void * jresult ;
84404   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84405   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84406
84407   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84408   {
84409     try {
84410       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
84411     } catch (std::out_of_range& e) {
84412       {
84413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84414       };
84415     } catch (std::exception& e) {
84416       {
84417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84418       };
84419     } catch (Dali::DaliException e) {
84420       {
84421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84422       };
84423     } catch (...) {
84424       {
84425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84426       };
84427     }
84428   }
84429
84430   jresult = (void *)result;
84431   return jresult;
84432 }
84433
84434
84435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
84436   void * jresult ;
84437   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84438   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84439
84440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84441   {
84442     try {
84443       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
84444     } catch (std::out_of_range& e) {
84445       {
84446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84447       };
84448     } catch (std::exception& e) {
84449       {
84450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84451       };
84452     } catch (Dali::DaliException e) {
84453       {
84454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84455       };
84456     } catch (...) {
84457       {
84458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84459       };
84460     }
84461   }
84462
84463   jresult = (void *)result;
84464   return jresult;
84465 }
84466
84467
84468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
84469   void * jresult ;
84470   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84471   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84472
84473   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84474   {
84475     try {
84476       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
84477     } catch (std::out_of_range& e) {
84478       {
84479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84480       };
84481     } catch (std::exception& e) {
84482       {
84483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84484       };
84485     } catch (Dali::DaliException e) {
84486       {
84487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84488       };
84489     } catch (...) {
84490       {
84491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84492       };
84493     }
84494   }
84495
84496   jresult = (void *)result;
84497   return jresult;
84498 }
84499
84500
84501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
84502   void * jresult ;
84503   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84504   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84505
84506   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84507   {
84508     try {
84509       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
84510     } catch (std::out_of_range& e) {
84511       {
84512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84513       };
84514     } catch (std::exception& e) {
84515       {
84516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84517       };
84518     } catch (Dali::DaliException e) {
84519       {
84520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84521       };
84522     } catch (...) {
84523       {
84524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84525       };
84526     }
84527   }
84528
84529   jresult = (void *)result;
84530   return jresult;
84531 }
84532
84533
84534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
84535   void * jresult ;
84536   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84537   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84538
84539   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84540   {
84541     try {
84542       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
84543     } catch (std::out_of_range& e) {
84544       {
84545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84546       };
84547     } catch (std::exception& e) {
84548       {
84549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84550       };
84551     } catch (Dali::DaliException e) {
84552       {
84553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84554       };
84555     } catch (...) {
84556       {
84557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84558       };
84559     }
84560   }
84561
84562   jresult = (void *)result;
84563   return jresult;
84564 }
84565
84566
84567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
84568   void * jresult ;
84569   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84570   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84571
84572   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84573   {
84574     try {
84575       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
84576     } catch (std::out_of_range& e) {
84577       {
84578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84579       };
84580     } catch (std::exception& e) {
84581       {
84582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84583       };
84584     } catch (Dali::DaliException e) {
84585       {
84586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84587       };
84588     } catch (...) {
84589       {
84590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84591       };
84592     }
84593   }
84594
84595   jresult = (void *)result;
84596   return jresult;
84597 }
84598
84599
84600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
84601   void * jresult ;
84602   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84603   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84604
84605   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84606   {
84607     try {
84608       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
84609     } catch (std::out_of_range& e) {
84610       {
84611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84612       };
84613     } catch (std::exception& e) {
84614       {
84615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84616       };
84617     } catch (Dali::DaliException e) {
84618       {
84619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84620       };
84621     } catch (...) {
84622       {
84623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84624       };
84625     }
84626   }
84627
84628   jresult = (void *)result;
84629   return jresult;
84630 }
84631
84632
84633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
84634   void * jresult ;
84635   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84636   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84637
84638   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84639   {
84640     try {
84641       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
84642     } catch (std::out_of_range& e) {
84643       {
84644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84645       };
84646     } catch (std::exception& e) {
84647       {
84648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84649       };
84650     } catch (Dali::DaliException e) {
84651       {
84652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84653       };
84654     } catch (...) {
84655       {
84656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84657       };
84658     }
84659   }
84660
84661   jresult = (void *)result;
84662   return jresult;
84663 }
84664
84665
84666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
84667   void * jresult ;
84668   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84669   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84670
84671   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84672   {
84673     try {
84674       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
84675     } catch (std::out_of_range& e) {
84676       {
84677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84678       };
84679     } catch (std::exception& e) {
84680       {
84681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84682       };
84683     } catch (Dali::DaliException e) {
84684       {
84685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84686       };
84687     } catch (...) {
84688       {
84689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84690       };
84691     }
84692   }
84693
84694   jresult = (void *)result;
84695   return jresult;
84696 }
84697
84698
84699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
84700   void * jresult ;
84701   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84702   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84703
84704   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84705   {
84706     try {
84707       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
84708     } catch (std::out_of_range& e) {
84709       {
84710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84711       };
84712     } catch (std::exception& e) {
84713       {
84714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84715       };
84716     } catch (Dali::DaliException e) {
84717       {
84718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84719       };
84720     } catch (...) {
84721       {
84722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84723       };
84724     }
84725   }
84726
84727   jresult = (void *)result;
84728   return jresult;
84729 }
84730
84731
84732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
84733   void * jresult ;
84734   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84735   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84736
84737   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84738   {
84739     try {
84740       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
84741     } catch (std::out_of_range& e) {
84742       {
84743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84744       };
84745     } catch (std::exception& e) {
84746       {
84747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84748       };
84749     } catch (Dali::DaliException e) {
84750       {
84751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84752       };
84753     } catch (...) {
84754       {
84755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84756       };
84757     }
84758   }
84759
84760   jresult = (void *)result;
84761   return jresult;
84762 }
84763
84764
84765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
84766   void * jresult ;
84767   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84768   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84769
84770   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84771   {
84772     try {
84773       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
84774     } catch (std::out_of_range& e) {
84775       {
84776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84777       };
84778     } catch (std::exception& e) {
84779       {
84780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84781       };
84782     } catch (Dali::DaliException e) {
84783       {
84784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84785       };
84786     } catch (...) {
84787       {
84788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84789       };
84790     }
84791   }
84792
84793   jresult = (void *)result;
84794   return jresult;
84795 }
84796
84797
84798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
84799   void * jresult ;
84800   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84801   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84802
84803   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84804   {
84805     try {
84806       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
84807     } catch (std::out_of_range& e) {
84808       {
84809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84810       };
84811     } catch (std::exception& e) {
84812       {
84813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84814       };
84815     } catch (Dali::DaliException e) {
84816       {
84817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84818       };
84819     } catch (...) {
84820       {
84821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84822       };
84823     }
84824   }
84825
84826   jresult = (void *)result;
84827   return jresult;
84828 }
84829
84830
84831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
84832   void * jresult ;
84833   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84834   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84835
84836   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84837   {
84838     try {
84839       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
84840     } catch (std::out_of_range& e) {
84841       {
84842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84843       };
84844     } catch (std::exception& e) {
84845       {
84846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84847       };
84848     } catch (Dali::DaliException e) {
84849       {
84850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84851       };
84852     } catch (...) {
84853       {
84854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84855       };
84856     }
84857   }
84858
84859   jresult = (void *)result;
84860   return jresult;
84861 }
84862
84863
84864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
84865   void * jresult ;
84866   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84867   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84868
84869   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84870   {
84871     try {
84872       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
84873     } catch (std::out_of_range& e) {
84874       {
84875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84876       };
84877     } catch (std::exception& e) {
84878       {
84879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84880       };
84881     } catch (Dali::DaliException e) {
84882       {
84883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84884       };
84885     } catch (...) {
84886       {
84887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84888       };
84889     }
84890   }
84891
84892   jresult = (void *)result;
84893   return jresult;
84894 }
84895
84896
84897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
84898   void * jresult ;
84899   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84900   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84901
84902   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84903   {
84904     try {
84905       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
84906     } catch (std::out_of_range& e) {
84907       {
84908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84909       };
84910     } catch (std::exception& e) {
84911       {
84912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84913       };
84914     } catch (Dali::DaliException e) {
84915       {
84916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84917       };
84918     } catch (...) {
84919       {
84920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84921       };
84922     }
84923   }
84924
84925   jresult = (void *)result;
84926   return jresult;
84927 }
84928
84929
84930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
84931   void * jresult ;
84932   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84933   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84934
84935   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84936   {
84937     try {
84938       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
84939     } catch (std::out_of_range& e) {
84940       {
84941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84942       };
84943     } catch (std::exception& e) {
84944       {
84945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84946       };
84947     } catch (Dali::DaliException e) {
84948       {
84949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84950       };
84951     } catch (...) {
84952       {
84953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84954       };
84955     }
84956   }
84957
84958   jresult = (void *)result;
84959   return jresult;
84960 }
84961
84962
84963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
84964   void * jresult ;
84965   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84966   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84967
84968   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84969   {
84970     try {
84971       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
84972     } catch (std::out_of_range& e) {
84973       {
84974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84975       };
84976     } catch (std::exception& e) {
84977       {
84978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84979       };
84980     } catch (Dali::DaliException e) {
84981       {
84982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84983       };
84984     } catch (...) {
84985       {
84986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84987       };
84988     }
84989   }
84990
84991   jresult = (void *)result;
84992   return jresult;
84993 }
84994
84995
84996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
84997   void * jresult ;
84998   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84999   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85000
85001   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85002   {
85003     try {
85004       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
85005     } catch (std::out_of_range& e) {
85006       {
85007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85008       };
85009     } catch (std::exception& e) {
85010       {
85011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85012       };
85013     } catch (Dali::DaliException e) {
85014       {
85015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85016       };
85017     } catch (...) {
85018       {
85019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85020       };
85021     }
85022   }
85023
85024   jresult = (void *)result;
85025   return jresult;
85026 }
85027
85028
85029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
85030   void * jresult ;
85031   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85032   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85033
85034   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85035   {
85036     try {
85037       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
85038     } catch (std::out_of_range& e) {
85039       {
85040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85041       };
85042     } catch (std::exception& e) {
85043       {
85044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85045       };
85046     } catch (Dali::DaliException e) {
85047       {
85048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85049       };
85050     } catch (...) {
85051       {
85052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85053       };
85054     }
85055   }
85056
85057   jresult = (void *)result;
85058   return jresult;
85059 }
85060
85061
85062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
85063   void * jresult ;
85064   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85065   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85066
85067   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85068   {
85069     try {
85070       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
85071     } catch (std::out_of_range& e) {
85072       {
85073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85074       };
85075     } catch (std::exception& e) {
85076       {
85077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85078       };
85079     } catch (Dali::DaliException e) {
85080       {
85081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85082       };
85083     } catch (...) {
85084       {
85085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85086       };
85087     }
85088   }
85089
85090   jresult = (void *)result;
85091   return jresult;
85092 }
85093
85094
85095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85096   void * jresult ;
85097   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85098   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85099
85100   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85101   {
85102     try {
85103       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85104     } catch (std::out_of_range& e) {
85105       {
85106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85107       };
85108     } catch (std::exception& e) {
85109       {
85110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85111       };
85112     } catch (Dali::DaliException e) {
85113       {
85114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85115       };
85116     } catch (...) {
85117       {
85118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85119       };
85120     }
85121   }
85122
85123   jresult = (void *)result;
85124   return jresult;
85125 }
85126
85127
85128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85129   void * jresult ;
85130   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85131   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85132
85133   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85134   {
85135     try {
85136       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85137     } catch (std::out_of_range& e) {
85138       {
85139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85140       };
85141     } catch (std::exception& e) {
85142       {
85143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85144       };
85145     } catch (Dali::DaliException e) {
85146       {
85147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85148       };
85149     } catch (...) {
85150       {
85151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85152       };
85153     }
85154   }
85155
85156   jresult = (void *)result;
85157   return jresult;
85158 }
85159
85160
85161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
85162   void * jresult ;
85163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85164   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
85165
85166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85167   {
85168     try {
85169       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
85170     } catch (std::out_of_range& e) {
85171       {
85172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85173       };
85174     } catch (std::exception& e) {
85175       {
85176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85177       };
85178     } catch (Dali::DaliException e) {
85179       {
85180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85181       };
85182     } catch (...) {
85183       {
85184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85185       };
85186     }
85187   }
85188
85189   jresult = (void *)result;
85190   return jresult;
85191 }
85192
85193
85194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
85195   void * jresult ;
85196   Dali::Toolkit::StyleManager *result = 0 ;
85197
85198   {
85199     try {
85200       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
85201     } catch (std::out_of_range& e) {
85202       {
85203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85204       };
85205     } catch (std::exception& e) {
85206       {
85207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85208       };
85209     } catch (Dali::DaliException e) {
85210       {
85211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85212       };
85213     } catch (...) {
85214       {
85215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85216       };
85217     }
85218   }
85219
85220   jresult = (void *)result;
85221   return jresult;
85222 }
85223
85224
85225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
85226   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85227
85228   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85229   {
85230     try {
85231       delete arg1;
85232     } catch (std::out_of_range& e) {
85233       {
85234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85235       };
85236     } catch (std::exception& e) {
85237       {
85238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85239       };
85240     } catch (Dali::DaliException e) {
85241       {
85242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85243       };
85244     } catch (...) {
85245       {
85246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85247       };
85248     }
85249   }
85250
85251 }
85252
85253
85254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
85255   void * jresult ;
85256   Dali::Toolkit::StyleManager result;
85257
85258   {
85259     try {
85260       result = Dali::Toolkit::StyleManager::Get();
85261     } catch (std::out_of_range& e) {
85262       {
85263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85264       };
85265     } catch (std::exception& e) {
85266       {
85267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85268       };
85269     } catch (Dali::DaliException e) {
85270       {
85271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85272       };
85273     } catch (...) {
85274       {
85275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85276       };
85277     }
85278   }
85279
85280   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
85281   return jresult;
85282 }
85283
85284
85285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
85286   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85287   std::string *arg2 = 0 ;
85288
85289   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85290   if (!jarg2) {
85291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85292     return ;
85293   }
85294   std::string arg2_str(jarg2);
85295   arg2 = &arg2_str;
85296   {
85297     try {
85298       (arg1)->ApplyTheme((std::string const &)*arg2);
85299     } catch (std::out_of_range& e) {
85300       {
85301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85302       };
85303     } catch (std::exception& e) {
85304       {
85305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85306       };
85307     } catch (Dali::DaliException e) {
85308       {
85309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85310       };
85311     } catch (...) {
85312       {
85313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85314       };
85315     }
85316   }
85317
85318
85319   //argout typemap for const std::string&
85320
85321 }
85322
85323
85324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
85325   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85326
85327   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85328   {
85329     try {
85330       (arg1)->ApplyDefaultTheme();
85331     } catch (std::out_of_range& e) {
85332       {
85333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85334       };
85335     } catch (std::exception& e) {
85336       {
85337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85338       };
85339     } catch (Dali::DaliException e) {
85340       {
85341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85342       };
85343     } catch (...) {
85344       {
85345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85346       };
85347     }
85348   }
85349
85350 }
85351
85352
85353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85354   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85355   std::string *arg2 = 0 ;
85356   Dali::Property::Value *arg3 = 0 ;
85357
85358   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85359   if (!jarg2) {
85360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85361     return ;
85362   }
85363   std::string arg2_str(jarg2);
85364   arg2 = &arg2_str;
85365   arg3 = (Dali::Property::Value *)jarg3;
85366   if (!arg3) {
85367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
85368     return ;
85369   }
85370   {
85371     try {
85372       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
85373     } catch (std::out_of_range& e) {
85374       {
85375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85376       };
85377     } catch (std::exception& e) {
85378       {
85379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85380       };
85381     } catch (Dali::DaliException e) {
85382       {
85383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85384       };
85385     } catch (...) {
85386       {
85387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85388       };
85389     }
85390   }
85391
85392
85393   //argout typemap for const std::string&
85394
85395 }
85396
85397
85398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85399   unsigned int jresult ;
85400   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85401   std::string *arg2 = 0 ;
85402   Dali::Property::Value *arg3 = 0 ;
85403   bool result;
85404
85405   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85406   if (!jarg2) {
85407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85408     return 0;
85409   }
85410   std::string arg2_str(jarg2);
85411   arg2 = &arg2_str;
85412   arg3 = (Dali::Property::Value *)jarg3;
85413   if (!arg3) {
85414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
85415     return 0;
85416   }
85417   {
85418     try {
85419       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
85420     } catch (std::out_of_range& e) {
85421       {
85422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85423       };
85424     } catch (std::exception& e) {
85425       {
85426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85427       };
85428     } catch (Dali::DaliException e) {
85429       {
85430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85431       };
85432     } catch (...) {
85433       {
85434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85435       };
85436     }
85437   }
85438
85439   jresult = result;
85440
85441   //argout typemap for const std::string&
85442
85443   return jresult;
85444 }
85445
85446
85447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
85448   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85449   Dali::Toolkit::Control arg2 ;
85450   std::string *arg3 = 0 ;
85451   std::string *arg4 = 0 ;
85452   Dali::Toolkit::Control *argp2 ;
85453
85454   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85455   argp2 = (Dali::Toolkit::Control *)jarg2;
85456   if (!argp2) {
85457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85458     return ;
85459   }
85460   arg2 = *argp2;
85461   if (!jarg3) {
85462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85463     return ;
85464   }
85465   std::string arg3_str(jarg3);
85466   arg3 = &arg3_str;
85467   if (!jarg4) {
85468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85469     return ;
85470   }
85471   std::string arg4_str(jarg4);
85472   arg4 = &arg4_str;
85473   {
85474     try {
85475       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
85476     } catch (std::out_of_range& e) {
85477       {
85478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85479       };
85480     } catch (std::exception& e) {
85481       {
85482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85483       };
85484     } catch (Dali::DaliException e) {
85485       {
85486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85487       };
85488     } catch (...) {
85489       {
85490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85491       };
85492     }
85493   }
85494
85495
85496   //argout typemap for const std::string&
85497
85498
85499   //argout typemap for const std::string&
85500
85501 }
85502
85503
85504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
85505   void * jresult ;
85506   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85507   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
85508
85509   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85510   {
85511     try {
85512       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
85513     } catch (std::out_of_range& e) {
85514       {
85515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85516       };
85517     } catch (std::exception& e) {
85518       {
85519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85520       };
85521     } catch (Dali::DaliException e) {
85522       {
85523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85524       };
85525     } catch (...) {
85526       {
85527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85528       };
85529     }
85530   }
85531
85532   jresult = (void *)result;
85533   return jresult;
85534 }
85535
85536
85537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
85538   int jresult ;
85539   int result;
85540
85541   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
85542   jresult = (int)result;
85543   return jresult;
85544 }
85545
85546
85547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
85548   int jresult ;
85549   int result;
85550
85551   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
85552   jresult = (int)result;
85553   return jresult;
85554 }
85555
85556
85557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
85558   int jresult ;
85559   int result;
85560
85561   result = (int)Dali::Toolkit::Slider::Property::VALUE;
85562   jresult = (int)result;
85563   return jresult;
85564 }
85565
85566
85567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
85568   int jresult ;
85569   int result;
85570
85571   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
85572   jresult = (int)result;
85573   return jresult;
85574 }
85575
85576
85577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
85578   int jresult ;
85579   int result;
85580
85581   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
85582   jresult = (int)result;
85583   return jresult;
85584 }
85585
85586
85587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
85588   int jresult ;
85589   int result;
85590
85591   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
85592   jresult = (int)result;
85593   return jresult;
85594 }
85595
85596
85597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
85598   int jresult ;
85599   int result;
85600
85601   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
85602   jresult = (int)result;
85603   return jresult;
85604 }
85605
85606
85607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
85608   int jresult ;
85609   int result;
85610
85611   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
85612   jresult = (int)result;
85613   return jresult;
85614 }
85615
85616
85617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
85618   int jresult ;
85619   int result;
85620
85621   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
85622   jresult = (int)result;
85623   return jresult;
85624 }
85625
85626
85627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
85628   int jresult ;
85629   int result;
85630
85631   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
85632   jresult = (int)result;
85633   return jresult;
85634 }
85635
85636
85637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
85638   int jresult ;
85639   int result;
85640
85641   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
85642   jresult = (int)result;
85643   return jresult;
85644 }
85645
85646
85647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
85648   int jresult ;
85649   int result;
85650
85651   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
85652   jresult = (int)result;
85653   return jresult;
85654 }
85655
85656
85657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
85658   int jresult ;
85659   int result;
85660
85661   result = (int)Dali::Toolkit::Slider::Property::MARKS;
85662   jresult = (int)result;
85663   return jresult;
85664 }
85665
85666
85667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
85668   int jresult ;
85669   int result;
85670
85671   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
85672   jresult = (int)result;
85673   return jresult;
85674 }
85675
85676
85677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
85678   int jresult ;
85679   int result;
85680
85681   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
85682   jresult = (int)result;
85683   return jresult;
85684 }
85685
85686
85687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
85688   void * jresult ;
85689   Dali::Toolkit::Slider::Property *result = 0 ;
85690
85691   {
85692     try {
85693       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
85694     } catch (std::out_of_range& e) {
85695       {
85696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85697       };
85698     } catch (std::exception& e) {
85699       {
85700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85701       };
85702     } catch (Dali::DaliException e) {
85703       {
85704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85705       };
85706     } catch (...) {
85707       {
85708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85709       };
85710     }
85711   }
85712
85713   jresult = (void *)result;
85714   return jresult;
85715 }
85716
85717
85718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
85719   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
85720
85721   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
85722   {
85723     try {
85724       delete arg1;
85725     } catch (std::out_of_range& e) {
85726       {
85727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85728       };
85729     } catch (std::exception& e) {
85730       {
85731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85732       };
85733     } catch (Dali::DaliException e) {
85734       {
85735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85736       };
85737     } catch (...) {
85738       {
85739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85740       };
85741     }
85742   }
85743
85744 }
85745
85746
85747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
85748   void * jresult ;
85749   Dali::Toolkit::Slider result;
85750
85751   {
85752     try {
85753       result = Dali::Toolkit::Slider::New();
85754     } catch (std::out_of_range& e) {
85755       {
85756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85757       };
85758     } catch (std::exception& e) {
85759       {
85760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85761       };
85762     } catch (Dali::DaliException e) {
85763       {
85764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85765       };
85766     } catch (...) {
85767       {
85768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85769       };
85770     }
85771   }
85772
85773   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85774   return jresult;
85775 }
85776
85777
85778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
85779   void * jresult ;
85780   Dali::Toolkit::Slider *result = 0 ;
85781
85782   {
85783     try {
85784       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
85785     } catch (std::out_of_range& e) {
85786       {
85787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85788       };
85789     } catch (std::exception& e) {
85790       {
85791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85792       };
85793     } catch (Dali::DaliException e) {
85794       {
85795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85796       };
85797     } catch (...) {
85798       {
85799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85800       };
85801     }
85802   }
85803
85804   jresult = (void *)result;
85805   return jresult;
85806 }
85807
85808
85809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
85810   void * jresult ;
85811   Dali::Toolkit::Slider *arg1 = 0 ;
85812   Dali::Toolkit::Slider *result = 0 ;
85813
85814   arg1 = (Dali::Toolkit::Slider *)jarg1;
85815   if (!arg1) {
85816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85817     return 0;
85818   }
85819   {
85820     try {
85821       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
85822     } catch (std::out_of_range& e) {
85823       {
85824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85825       };
85826     } catch (std::exception& e) {
85827       {
85828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85829       };
85830     } catch (Dali::DaliException e) {
85831       {
85832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85833       };
85834     } catch (...) {
85835       {
85836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85837       };
85838     }
85839   }
85840
85841   jresult = (void *)result;
85842   return jresult;
85843 }
85844
85845
85846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
85847   void * jresult ;
85848   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85849   Dali::Toolkit::Slider *arg2 = 0 ;
85850   Dali::Toolkit::Slider *result = 0 ;
85851
85852   arg1 = (Dali::Toolkit::Slider *)jarg1;
85853   arg2 = (Dali::Toolkit::Slider *)jarg2;
85854   if (!arg2) {
85855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85856     return 0;
85857   }
85858   {
85859     try {
85860       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
85861     } catch (std::out_of_range& e) {
85862       {
85863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85864       };
85865     } catch (std::exception& e) {
85866       {
85867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85868       };
85869     } catch (Dali::DaliException e) {
85870       {
85871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85872       };
85873     } catch (...) {
85874       {
85875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85876       };
85877     }
85878   }
85879
85880   jresult = (void *)result;
85881   return jresult;
85882 }
85883
85884
85885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
85886   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85887
85888   arg1 = (Dali::Toolkit::Slider *)jarg1;
85889   {
85890     try {
85891       delete arg1;
85892     } catch (std::out_of_range& e) {
85893       {
85894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85895       };
85896     } catch (std::exception& e) {
85897       {
85898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85899       };
85900     } catch (Dali::DaliException e) {
85901       {
85902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85903       };
85904     } catch (...) {
85905       {
85906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85907       };
85908     }
85909   }
85910
85911 }
85912
85913
85914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
85915   void * jresult ;
85916   Dali::BaseHandle arg1 ;
85917   Dali::BaseHandle *argp1 ;
85918   Dali::Toolkit::Slider result;
85919
85920   argp1 = (Dali::BaseHandle *)jarg1;
85921   if (!argp1) {
85922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85923     return 0;
85924   }
85925   arg1 = *argp1;
85926   {
85927     try {
85928       result = Dali::Toolkit::Slider::DownCast(arg1);
85929     } catch (std::out_of_range& e) {
85930       {
85931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85932       };
85933     } catch (std::exception& e) {
85934       {
85935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85936       };
85937     } catch (Dali::DaliException e) {
85938       {
85939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85940       };
85941     } catch (...) {
85942       {
85943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85944       };
85945     }
85946   }
85947
85948   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85949   return jresult;
85950 }
85951
85952
85953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
85954   void * jresult ;
85955   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85956   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85957
85958   arg1 = (Dali::Toolkit::Slider *)jarg1;
85959   {
85960     try {
85961       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
85962     } catch (std::out_of_range& e) {
85963       {
85964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85965       };
85966     } catch (std::exception& e) {
85967       {
85968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85969       };
85970     } catch (Dali::DaliException e) {
85971       {
85972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85973       };
85974     } catch (...) {
85975       {
85976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85977       };
85978     }
85979   }
85980
85981   jresult = (void *)result;
85982   return jresult;
85983 }
85984
85985
85986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
85987   void * jresult ;
85988   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85989   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85990
85991   arg1 = (Dali::Toolkit::Slider *)jarg1;
85992   {
85993     try {
85994       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
85995     } catch (std::out_of_range& e) {
85996       {
85997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85998       };
85999     } catch (std::exception& e) {
86000       {
86001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86002       };
86003     } catch (Dali::DaliException e) {
86004       {
86005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86006       };
86007     } catch (...) {
86008       {
86009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86010       };
86011     }
86012   }
86013
86014   jresult = (void *)result;
86015   return jresult;
86016 }
86017
86018
86019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
86020   void * jresult ;
86021   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86022   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
86023
86024   arg1 = (Dali::Toolkit::Slider *)jarg1;
86025   {
86026     try {
86027       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
86028     } catch (std::out_of_range& e) {
86029       {
86030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86031       };
86032     } catch (std::exception& e) {
86033       {
86034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86035       };
86036     } catch (Dali::DaliException e) {
86037       {
86038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86039       };
86040     } catch (...) {
86041       {
86042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86043       };
86044     }
86045   }
86046
86047   jresult = (void *)result;
86048   return jresult;
86049 }
86050
86051
86052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
86053   int jresult ;
86054   int result;
86055
86056   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
86057   jresult = (int)result;
86058   return jresult;
86059 }
86060
86061
86062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
86063   int jresult ;
86064   int result;
86065
86066   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
86067   jresult = (int)result;
86068   return jresult;
86069 }
86070
86071
86072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
86073   int jresult ;
86074   int result;
86075
86076   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
86077   jresult = (int)result;
86078   return jresult;
86079 }
86080
86081
86082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86083   int jresult ;
86084   int result;
86085
86086   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86087   jresult = (int)result;
86088   return jresult;
86089 }
86090
86091
86092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86093   int result;
86094
86095   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86096
86097   return result;
86098 }
86099
86100
86101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86102   void * jresult ;
86103   Dali::Toolkit::VideoView::Property *result = 0 ;
86104
86105   {
86106     try {
86107       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86108     } catch (std::out_of_range& e) {
86109       {
86110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86111       };
86112     } catch (std::exception& e) {
86113       {
86114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86115       };
86116     } catch (Dali::DaliException e) {
86117       {
86118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86119       };
86120     } catch (...) {
86121       {
86122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86123       };
86124     }
86125   }
86126
86127   jresult = (void *)result;
86128   return jresult;
86129 }
86130
86131
86132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86133   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86134
86135   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86136   {
86137     try {
86138       delete arg1;
86139     } catch (std::out_of_range& e) {
86140       {
86141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86142       };
86143     } catch (std::exception& e) {
86144       {
86145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86146       };
86147     } catch (Dali::DaliException e) {
86148       {
86149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86150       };
86151     } catch (...) {
86152       {
86153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86154       };
86155     }
86156   }
86157
86158 }
86159
86160
86161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
86162   void * jresult ;
86163   Dali::Toolkit::VideoView result;
86164
86165   {
86166     try {
86167       result = Dali::Toolkit::VideoView::New();
86168     } catch (std::out_of_range& e) {
86169       {
86170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86171       };
86172     } catch (std::exception& e) {
86173       {
86174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86175       };
86176     } catch (Dali::DaliException e) {
86177       {
86178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86179       };
86180     } catch (...) {
86181       {
86182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86183       };
86184     }
86185   }
86186
86187   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86188   return jresult;
86189 }
86190
86191
86192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
86193   void * jresult ;
86194   std::string *arg1 = 0 ;
86195   Dali::Toolkit::VideoView result;
86196
86197   if (!jarg1) {
86198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86199     return 0;
86200   }
86201   std::string arg1_str(jarg1);
86202   arg1 = &arg1_str;
86203   {
86204     try {
86205       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
86206     } catch (std::out_of_range& e) {
86207       {
86208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86209       };
86210     } catch (std::exception& e) {
86211       {
86212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86213       };
86214     } catch (Dali::DaliException e) {
86215       {
86216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86217       };
86218     } catch (...) {
86219       {
86220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86221       };
86222     }
86223   }
86224
86225   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86226
86227   //argout typemap for const std::string&
86228
86229   return jresult;
86230 }
86231
86232
86233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
86234   void * jresult ;
86235   Dali::Toolkit::VideoView result;
86236   {
86237     try {
86238       result = Dali::Toolkit::VideoView::New(swCodec);
86239     } catch (std::out_of_range& e) {
86240       {
86241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86242       };
86243     } catch (std::exception& e) {
86244       {
86245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86246       };
86247     } catch (Dali::DaliException e) {
86248       {
86249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86250       };
86251     } catch (...) {
86252       {
86253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86254       };
86255     }
86256   }
86257
86258   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86259
86260   //argout typemap for const std::string&
86261
86262   return jresult;
86263 }
86264
86265
86266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
86267   void * jresult ;
86268   std::string *arg1 = 0 ;
86269   Dali::Toolkit::VideoView result;
86270
86271   if (!jarg1) {
86272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86273     return 0;
86274   }
86275   std::string arg1_str(jarg1);
86276   arg1 = &arg1_str;
86277   {
86278     try {
86279       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
86280     } catch (std::out_of_range& e) {
86281       {
86282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86283       };
86284     } catch (std::exception& e) {
86285       {
86286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86287       };
86288     } catch (Dali::DaliException e) {
86289       {
86290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86291       };
86292     } catch (...) {
86293       {
86294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86295       };
86296     }
86297   }
86298
86299   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86300
86301   //argout typemap for const std::string&
86302
86303   return jresult;
86304 }
86305
86306
86307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
86308   void * jresult ;
86309   Dali::Toolkit::VideoView *result = 0 ;
86310
86311   {
86312     try {
86313       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
86314     } catch (std::out_of_range& e) {
86315       {
86316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86317       };
86318     } catch (std::exception& e) {
86319       {
86320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86321       };
86322     } catch (Dali::DaliException e) {
86323       {
86324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86325       };
86326     } catch (...) {
86327       {
86328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86329       };
86330     }
86331   }
86332
86333   jresult = (void *)result;
86334   return jresult;
86335 }
86336
86337
86338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
86339   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86340
86341   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86342   {
86343     try {
86344       delete arg1;
86345     } catch (std::out_of_range& e) {
86346       {
86347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86348       };
86349     } catch (std::exception& e) {
86350       {
86351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86352       };
86353     } catch (Dali::DaliException e) {
86354       {
86355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86356       };
86357     } catch (...) {
86358       {
86359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86360       };
86361     }
86362   }
86363
86364 }
86365
86366
86367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
86368   void * jresult ;
86369   Dali::Toolkit::VideoView *arg1 = 0 ;
86370   Dali::Toolkit::VideoView *result = 0 ;
86371
86372   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86373   if (!arg1) {
86374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86375     return 0;
86376   }
86377   {
86378     try {
86379       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
86380     } catch (std::out_of_range& e) {
86381       {
86382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86383       };
86384     } catch (std::exception& e) {
86385       {
86386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86387       };
86388     } catch (Dali::DaliException e) {
86389       {
86390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86391       };
86392     } catch (...) {
86393       {
86394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86395       };
86396     }
86397   }
86398
86399   jresult = (void *)result;
86400   return jresult;
86401 }
86402
86403
86404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
86405   void * jresult ;
86406   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86407   Dali::Toolkit::VideoView *arg2 = 0 ;
86408   Dali::Toolkit::VideoView *result = 0 ;
86409
86410   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86411   arg2 = (Dali::Toolkit::VideoView *)jarg2;
86412   if (!arg2) {
86413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86414     return 0;
86415   }
86416   {
86417     try {
86418       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
86419     } catch (std::out_of_range& e) {
86420       {
86421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86422       };
86423     } catch (std::exception& e) {
86424       {
86425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86426       };
86427     } catch (Dali::DaliException e) {
86428       {
86429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86430       };
86431     } catch (...) {
86432       {
86433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86434       };
86435     }
86436   }
86437
86438   jresult = (void *)result;
86439   return jresult;
86440 }
86441
86442
86443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
86444   void * jresult ;
86445   Dali::BaseHandle arg1 ;
86446   Dali::BaseHandle *argp1 ;
86447   Dali::Toolkit::VideoView result;
86448
86449   argp1 = (Dali::BaseHandle *)jarg1;
86450   if (!argp1) {
86451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86452     return 0;
86453   }
86454   arg1 = *argp1;
86455   {
86456     try {
86457       result = Dali::Toolkit::VideoView::DownCast(arg1);
86458     } catch (std::out_of_range& e) {
86459       {
86460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86461       };
86462     } catch (std::exception& e) {
86463       {
86464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86465       };
86466     } catch (Dali::DaliException e) {
86467       {
86468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86469       };
86470     } catch (...) {
86471       {
86472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86473       };
86474     }
86475   }
86476
86477   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86478   return jresult;
86479 }
86480
86481
86482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
86483   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86484
86485   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86486   {
86487     try {
86488       (arg1)->Play();
86489     } catch (std::out_of_range& e) {
86490       {
86491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86492       };
86493     } catch (std::exception& e) {
86494       {
86495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86496       };
86497     } catch (Dali::DaliException e) {
86498       {
86499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86500       };
86501     } catch (...) {
86502       {
86503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86504       };
86505     }
86506   }
86507
86508 }
86509
86510
86511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
86512   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86513
86514   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86515   {
86516     try {
86517       (arg1)->Pause();
86518     } catch (std::out_of_range& e) {
86519       {
86520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86521       };
86522     } catch (std::exception& e) {
86523       {
86524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86525       };
86526     } catch (Dali::DaliException e) {
86527       {
86528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86529       };
86530     } catch (...) {
86531       {
86532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86533       };
86534     }
86535   }
86536
86537 }
86538
86539
86540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
86541   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86542
86543   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86544   {
86545     try {
86546       (arg1)->Stop();
86547     } catch (std::out_of_range& e) {
86548       {
86549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86550       };
86551     } catch (std::exception& e) {
86552       {
86553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86554       };
86555     } catch (Dali::DaliException e) {
86556       {
86557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86558       };
86559     } catch (...) {
86560       {
86561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86562       };
86563     }
86564   }
86565
86566 }
86567
86568
86569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
86570   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86571   int arg2 ;
86572
86573   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86574   arg2 = (int)jarg2;
86575   {
86576     try {
86577       (arg1)->Forward(arg2);
86578     } catch (std::out_of_range& e) {
86579       {
86580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86581       };
86582     } catch (std::exception& e) {
86583       {
86584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86585       };
86586     } catch (Dali::DaliException e) {
86587       {
86588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86589       };
86590     } catch (...) {
86591       {
86592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86593       };
86594     }
86595   }
86596
86597 }
86598
86599
86600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
86601   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86602   int arg2 ;
86603
86604   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86605   arg2 = (int)jarg2;
86606   {
86607     try {
86608       (arg1)->Backward(arg2);
86609     } catch (std::out_of_range& e) {
86610       {
86611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86612       };
86613     } catch (std::exception& e) {
86614       {
86615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86616       };
86617     } catch (Dali::DaliException e) {
86618       {
86619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86620       };
86621     } catch (...) {
86622       {
86623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86624       };
86625     }
86626   }
86627
86628 }
86629
86630
86631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
86632   void * jresult ;
86633   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86634   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
86635
86636   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86637   {
86638     try {
86639       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
86640     } catch (std::out_of_range& e) {
86641       {
86642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86643       };
86644     } catch (std::exception& e) {
86645       {
86646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86647       };
86648     } catch (Dali::DaliException e) {
86649       {
86650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86651       };
86652     } catch (...) {
86653       {
86654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86655       };
86656     }
86657   }
86658
86659   jresult = (void *)result;
86660   return jresult;
86661 }
86662
86663
86664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
86665   int jresult ;
86666   int result;
86667
86668   result = (int)Dali::Toolkit::Popup::Property::TITLE;
86669   jresult = (int)result;
86670   return jresult;
86671 }
86672
86673
86674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
86675   int jresult ;
86676   int result;
86677
86678   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
86679   jresult = (int)result;
86680   return jresult;
86681 }
86682
86683
86684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
86685   int jresult ;
86686   int result;
86687
86688   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
86689   jresult = (int)result;
86690   return jresult;
86691 }
86692
86693
86694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
86695   int jresult ;
86696   int result;
86697
86698   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
86699   jresult = (int)result;
86700   return jresult;
86701 }
86702
86703
86704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
86705   int jresult ;
86706   int result;
86707
86708   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
86709   jresult = (int)result;
86710   return jresult;
86711 }
86712
86713
86714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
86715   int jresult ;
86716   int result;
86717
86718   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
86719   jresult = (int)result;
86720   return jresult;
86721 }
86722
86723
86724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
86725   int jresult ;
86726   int result;
86727
86728   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
86729   jresult = (int)result;
86730   return jresult;
86731 }
86732
86733
86734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
86735   int jresult ;
86736   int result;
86737
86738   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
86739   jresult = (int)result;
86740   return jresult;
86741 }
86742
86743
86744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
86745   int jresult ;
86746   int result;
86747
86748   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
86749   jresult = (int)result;
86750   return jresult;
86751 }
86752
86753
86754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
86755   int jresult ;
86756   int result;
86757
86758   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
86759   jresult = (int)result;
86760   return jresult;
86761 }
86762
86763
86764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
86765   int jresult ;
86766   int result;
86767
86768   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
86769   jresult = (int)result;
86770   return jresult;
86771 }
86772
86773
86774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
86775   int jresult ;
86776   int result;
86777
86778   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
86779   jresult = (int)result;
86780   return jresult;
86781 }
86782
86783
86784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
86785   int jresult ;
86786   int result;
86787
86788   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
86789   jresult = (int)result;
86790   return jresult;
86791 }
86792
86793
86794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
86795   int jresult ;
86796   int result;
86797
86798   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
86799   jresult = (int)result;
86800   return jresult;
86801 }
86802
86803
86804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
86805   int jresult ;
86806   int result;
86807
86808   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
86809   jresult = (int)result;
86810   return jresult;
86811 }
86812
86813
86814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
86815   int jresult ;
86816   int result;
86817
86818   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
86819   jresult = (int)result;
86820   return jresult;
86821 }
86822
86823
86824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
86825   int jresult ;
86826   int result;
86827
86828   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
86829   jresult = (int)result;
86830   return jresult;
86831 }
86832
86833
86834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
86835   int jresult ;
86836   int result;
86837
86838   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
86839   jresult = (int)result;
86840   return jresult;
86841 }
86842
86843
86844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
86845   int jresult ;
86846   int result;
86847
86848   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
86849   jresult = (int)result;
86850   return jresult;
86851 }
86852
86853
86854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
86855   int jresult ;
86856   int result;
86857
86858   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
86859   jresult = (int)result;
86860   return jresult;
86861 }
86862
86863
86864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
86865   int jresult ;
86866   int result;
86867
86868   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
86869   jresult = (int)result;
86870   return jresult;
86871 }
86872
86873
86874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
86875   void * jresult ;
86876   Dali::Toolkit::Popup::Property *result = 0 ;
86877
86878   {
86879     try {
86880       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
86881     } catch (std::out_of_range& e) {
86882       {
86883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86884       };
86885     } catch (std::exception& e) {
86886       {
86887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86888       };
86889     } catch (Dali::DaliException e) {
86890       {
86891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86892       };
86893     } catch (...) {
86894       {
86895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86896       };
86897     }
86898   }
86899
86900   jresult = (void *)result;
86901   return jresult;
86902 }
86903
86904
86905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
86906   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
86907
86908   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
86909   {
86910     try {
86911       delete arg1;
86912     } catch (std::out_of_range& e) {
86913       {
86914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86915       };
86916     } catch (std::exception& e) {
86917       {
86918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86919       };
86920     } catch (Dali::DaliException e) {
86921       {
86922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86923       };
86924     } catch (...) {
86925       {
86926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86927       };
86928     }
86929   }
86930
86931 }
86932
86933
86934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
86935   void * jresult ;
86936   Dali::Toolkit::Popup *result = 0 ;
86937
86938   {
86939     try {
86940       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
86941     } catch (std::out_of_range& e) {
86942       {
86943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86944       };
86945     } catch (std::exception& e) {
86946       {
86947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86948       };
86949     } catch (Dali::DaliException e) {
86950       {
86951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86952       };
86953     } catch (...) {
86954       {
86955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86956       };
86957     }
86958   }
86959
86960   jresult = (void *)result;
86961   return jresult;
86962 }
86963
86964
86965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
86966   void * jresult ;
86967   Dali::Toolkit::Popup result;
86968
86969   {
86970     try {
86971       result = Dali::Toolkit::Popup::New();
86972     } catch (std::out_of_range& e) {
86973       {
86974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86975       };
86976     } catch (std::exception& e) {
86977       {
86978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86979       };
86980     } catch (Dali::DaliException e) {
86981       {
86982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86983       };
86984     } catch (...) {
86985       {
86986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86987       };
86988     }
86989   }
86990
86991   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86992   return jresult;
86993 }
86994
86995
86996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
86997   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86998
86999   arg1 = (Dali::Toolkit::Popup *)jarg1;
87000   {
87001     try {
87002       delete arg1;
87003     } catch (std::out_of_range& e) {
87004       {
87005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87006       };
87007     } catch (std::exception& e) {
87008       {
87009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87010       };
87011     } catch (Dali::DaliException e) {
87012       {
87013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87014       };
87015     } catch (...) {
87016       {
87017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87018       };
87019     }
87020   }
87021
87022 }
87023
87024
87025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
87026   void * jresult ;
87027   Dali::Toolkit::Popup *arg1 = 0 ;
87028   Dali::Toolkit::Popup *result = 0 ;
87029
87030   arg1 = (Dali::Toolkit::Popup *)jarg1;
87031   if (!arg1) {
87032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87033     return 0;
87034   }
87035   {
87036     try {
87037       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
87038     } catch (std::out_of_range& e) {
87039       {
87040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87041       };
87042     } catch (std::exception& e) {
87043       {
87044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87045       };
87046     } catch (Dali::DaliException e) {
87047       {
87048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87049       };
87050     } catch (...) {
87051       {
87052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87053       };
87054     }
87055   }
87056
87057   jresult = (void *)result;
87058   return jresult;
87059 }
87060
87061
87062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
87063   void * jresult ;
87064   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87065   Dali::Toolkit::Popup *arg2 = 0 ;
87066   Dali::Toolkit::Popup *result = 0 ;
87067
87068   arg1 = (Dali::Toolkit::Popup *)jarg1;
87069   arg2 = (Dali::Toolkit::Popup *)jarg2;
87070   if (!arg2) {
87071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87072     return 0;
87073   }
87074   {
87075     try {
87076       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
87077     } catch (std::out_of_range& e) {
87078       {
87079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87080       };
87081     } catch (std::exception& e) {
87082       {
87083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87084       };
87085     } catch (Dali::DaliException e) {
87086       {
87087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87088       };
87089     } catch (...) {
87090       {
87091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87092       };
87093     }
87094   }
87095
87096   jresult = (void *)result;
87097   return jresult;
87098 }
87099
87100
87101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
87102   void * jresult ;
87103   Dali::BaseHandle arg1 ;
87104   Dali::BaseHandle *argp1 ;
87105   Dali::Toolkit::Popup result;
87106
87107   argp1 = (Dali::BaseHandle *)jarg1;
87108   if (!argp1) {
87109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87110     return 0;
87111   }
87112   arg1 = *argp1;
87113   {
87114     try {
87115       result = Dali::Toolkit::Popup::DownCast(arg1);
87116     } catch (std::out_of_range& e) {
87117       {
87118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87119       };
87120     } catch (std::exception& e) {
87121       {
87122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87123       };
87124     } catch (Dali::DaliException e) {
87125       {
87126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87127       };
87128     } catch (...) {
87129       {
87130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87131       };
87132     }
87133   }
87134
87135   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87136   return jresult;
87137 }
87138
87139
87140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
87141   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87142   Dali::Actor arg2 ;
87143   Dali::Actor *argp2 ;
87144
87145   arg1 = (Dali::Toolkit::Popup *)jarg1;
87146   argp2 = (Dali::Actor *)jarg2;
87147   if (!argp2) {
87148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87149     return ;
87150   }
87151   arg2 = *argp2;
87152   {
87153     try {
87154       (arg1)->SetTitle(arg2);
87155     } catch (std::out_of_range& e) {
87156       {
87157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87158       };
87159     } catch (std::exception& e) {
87160       {
87161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87162       };
87163     } catch (Dali::DaliException e) {
87164       {
87165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87166       };
87167     } catch (...) {
87168       {
87169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87170       };
87171     }
87172   }
87173
87174 }
87175
87176
87177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87178   void * jresult ;
87179   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87180   Dali::Actor result;
87181
87182   arg1 = (Dali::Toolkit::Popup *)jarg1;
87183   {
87184     try {
87185       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87186     } catch (std::out_of_range& e) {
87187       {
87188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87189       };
87190     } catch (std::exception& e) {
87191       {
87192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87193       };
87194     } catch (Dali::DaliException e) {
87195       {
87196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87197       };
87198     } catch (...) {
87199       {
87200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87201       };
87202     }
87203   }
87204
87205   jresult = new Dali::Actor((const Dali::Actor &)result);
87206   return jresult;
87207 }
87208
87209
87210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87211   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87212   Dali::Actor arg2 ;
87213   Dali::Actor *argp2 ;
87214
87215   arg1 = (Dali::Toolkit::Popup *)jarg1;
87216   argp2 = (Dali::Actor *)jarg2;
87217   if (!argp2) {
87218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87219     return ;
87220   }
87221   arg2 = *argp2;
87222   {
87223     try {
87224       (arg1)->SetContent(arg2);
87225     } catch (std::out_of_range& e) {
87226       {
87227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87228       };
87229     } catch (std::exception& e) {
87230       {
87231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87232       };
87233     } catch (Dali::DaliException e) {
87234       {
87235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87236       };
87237     } catch (...) {
87238       {
87239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87240       };
87241     }
87242   }
87243
87244 }
87245
87246
87247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
87248   void * jresult ;
87249   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87250   Dali::Actor result;
87251
87252   arg1 = (Dali::Toolkit::Popup *)jarg1;
87253   {
87254     try {
87255       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
87256     } catch (std::out_of_range& e) {
87257       {
87258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87259       };
87260     } catch (std::exception& e) {
87261       {
87262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87263       };
87264     } catch (Dali::DaliException e) {
87265       {
87266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87267       };
87268     } catch (...) {
87269       {
87270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87271       };
87272     }
87273   }
87274
87275   jresult = new Dali::Actor((const Dali::Actor &)result);
87276   return jresult;
87277 }
87278
87279
87280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
87281   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87282   Dali::Actor arg2 ;
87283   Dali::Actor *argp2 ;
87284
87285   arg1 = (Dali::Toolkit::Popup *)jarg1;
87286   argp2 = (Dali::Actor *)jarg2;
87287   if (!argp2) {
87288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87289     return ;
87290   }
87291   arg2 = *argp2;
87292   {
87293     try {
87294       (arg1)->SetFooter(arg2);
87295     } catch (std::out_of_range& e) {
87296       {
87297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87298       };
87299     } catch (std::exception& e) {
87300       {
87301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87302       };
87303     } catch (Dali::DaliException e) {
87304       {
87305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87306       };
87307     } catch (...) {
87308       {
87309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87310       };
87311     }
87312   }
87313
87314 }
87315
87316
87317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
87318   void * jresult ;
87319   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87320   Dali::Actor result;
87321
87322   arg1 = (Dali::Toolkit::Popup *)jarg1;
87323   {
87324     try {
87325       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
87326     } catch (std::out_of_range& e) {
87327       {
87328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87329       };
87330     } catch (std::exception& e) {
87331       {
87332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87333       };
87334     } catch (Dali::DaliException e) {
87335       {
87336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87337       };
87338     } catch (...) {
87339       {
87340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87341       };
87342     }
87343   }
87344
87345   jresult = new Dali::Actor((const Dali::Actor &)result);
87346   return jresult;
87347 }
87348
87349
87350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
87351   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87352   Dali::Toolkit::Popup::DisplayState arg2 ;
87353
87354   arg1 = (Dali::Toolkit::Popup *)jarg1;
87355   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
87356   {
87357     try {
87358       (arg1)->SetDisplayState(arg2);
87359     } catch (std::out_of_range& e) {
87360       {
87361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87362       };
87363     } catch (std::exception& e) {
87364       {
87365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87366       };
87367     } catch (Dali::DaliException e) {
87368       {
87369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87370       };
87371     } catch (...) {
87372       {
87373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87374       };
87375     }
87376   }
87377
87378 }
87379
87380
87381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
87382   int jresult ;
87383   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87384   Dali::Toolkit::Popup::DisplayState result;
87385
87386   arg1 = (Dali::Toolkit::Popup *)jarg1;
87387   {
87388     try {
87389       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
87390     } catch (std::out_of_range& e) {
87391       {
87392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87393       };
87394     } catch (std::exception& e) {
87395       {
87396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87397       };
87398     } catch (Dali::DaliException e) {
87399       {
87400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87401       };
87402     } catch (...) {
87403       {
87404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87405       };
87406     }
87407   }
87408
87409   jresult = (int)result;
87410   return jresult;
87411 }
87412
87413
87414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
87415   void * jresult ;
87416   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87417   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
87418
87419   arg1 = (Dali::Toolkit::Popup *)jarg1;
87420   {
87421     try {
87422       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
87423     } catch (std::out_of_range& e) {
87424       {
87425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87426       };
87427     } catch (std::exception& e) {
87428       {
87429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87430       };
87431     } catch (Dali::DaliException e) {
87432       {
87433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87434       };
87435     } catch (...) {
87436       {
87437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87438       };
87439     }
87440   }
87441
87442   jresult = (void *)result;
87443   return jresult;
87444 }
87445
87446
87447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
87448   void * jresult ;
87449   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87450   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87451
87452   arg1 = (Dali::Toolkit::Popup *)jarg1;
87453   {
87454     try {
87455       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
87456     } catch (std::out_of_range& e) {
87457       {
87458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87459       };
87460     } catch (std::exception& e) {
87461       {
87462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87463       };
87464     } catch (Dali::DaliException e) {
87465       {
87466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87467       };
87468     } catch (...) {
87469       {
87470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87471       };
87472     }
87473   }
87474
87475   jresult = (void *)result;
87476   return jresult;
87477 }
87478
87479
87480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
87481   void * jresult ;
87482   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87483   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87484
87485   arg1 = (Dali::Toolkit::Popup *)jarg1;
87486   {
87487     try {
87488       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
87489     } catch (std::out_of_range& e) {
87490       {
87491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87492       };
87493     } catch (std::exception& e) {
87494       {
87495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87496       };
87497     } catch (Dali::DaliException e) {
87498       {
87499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87500       };
87501     } catch (...) {
87502       {
87503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87504       };
87505     }
87506   }
87507
87508   jresult = (void *)result;
87509   return jresult;
87510 }
87511
87512
87513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
87514   void * jresult ;
87515   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87516   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87517
87518   arg1 = (Dali::Toolkit::Popup *)jarg1;
87519   {
87520     try {
87521       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
87522     } catch (std::out_of_range& e) {
87523       {
87524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87525       };
87526     } catch (std::exception& e) {
87527       {
87528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87529       };
87530     } catch (Dali::DaliException e) {
87531       {
87532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87533       };
87534     } catch (...) {
87535       {
87536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87537       };
87538     }
87539   }
87540
87541   jresult = (void *)result;
87542   return jresult;
87543 }
87544
87545
87546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
87547   void * jresult ;
87548   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87549   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87550
87551   arg1 = (Dali::Toolkit::Popup *)jarg1;
87552   {
87553     try {
87554       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
87555     } catch (std::out_of_range& e) {
87556       {
87557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87558       };
87559     } catch (std::exception& e) {
87560       {
87561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87562       };
87563     } catch (Dali::DaliException e) {
87564       {
87565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87566       };
87567     } catch (...) {
87568       {
87569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87570       };
87571     }
87572   }
87573
87574   jresult = (void *)result;
87575   return jresult;
87576 }
87577
87578
87579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
87580   int jresult ;
87581   int result;
87582
87583   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
87584   jresult = (int)result;
87585   return jresult;
87586 }
87587
87588
87589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
87590   int jresult ;
87591   int result;
87592
87593   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
87594   jresult = (int)result;
87595   return jresult;
87596 }
87597
87598
87599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
87600   int jresult ;
87601   int result;
87602
87603   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
87604   jresult = (int)result;
87605   return jresult;
87606 }
87607
87608
87609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
87610   int jresult ;
87611   int result;
87612
87613   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
87614   jresult = (int)result;
87615   return jresult;
87616 }
87617
87618
87619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
87620   int jresult ;
87621   int result;
87622
87623   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
87624   jresult = (int)result;
87625   return jresult;
87626 }
87627
87628
87629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
87630   int jresult ;
87631   int result;
87632
87633   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
87634   jresult = (int)result;
87635   return jresult;
87636 }
87637
87638
87639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
87640   int jresult ;
87641   int result;
87642
87643   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
87644   jresult = (int)result;
87645   return jresult;
87646 }
87647
87648
87649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
87650   int jresult ;
87651   int result;
87652
87653   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
87654   jresult = (int)result;
87655   return jresult;
87656 }
87657
87658
87659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
87660   int jresult ;
87661   int result;
87662
87663   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
87664   jresult = (int)result;
87665   return jresult;
87666 }
87667
87668
87669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
87670   void * jresult ;
87671   Dali::Toolkit::ProgressBar::Property *result = 0 ;
87672
87673   {
87674     try {
87675       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
87676     } catch (std::out_of_range& e) {
87677       {
87678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87679       };
87680     } catch (std::exception& e) {
87681       {
87682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87683       };
87684     } catch (Dali::DaliException e) {
87685       {
87686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87687       };
87688     } catch (...) {
87689       {
87690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87691       };
87692     }
87693   }
87694
87695   jresult = (void *)result;
87696   return jresult;
87697 }
87698
87699
87700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
87701   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
87702
87703   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
87704   {
87705     try {
87706       delete arg1;
87707     } catch (std::out_of_range& e) {
87708       {
87709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87710       };
87711     } catch (std::exception& e) {
87712       {
87713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87714       };
87715     } catch (Dali::DaliException e) {
87716       {
87717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87718       };
87719     } catch (...) {
87720       {
87721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87722       };
87723     }
87724   }
87725
87726 }
87727
87728
87729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
87730   void * jresult ;
87731   Dali::Toolkit::ProgressBar result;
87732
87733   {
87734     try {
87735       result = Dali::Toolkit::ProgressBar::New();
87736     } catch (std::out_of_range& e) {
87737       {
87738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87739       };
87740     } catch (std::exception& e) {
87741       {
87742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87743       };
87744     } catch (Dali::DaliException e) {
87745       {
87746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87747       };
87748     } catch (...) {
87749       {
87750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87751       };
87752     }
87753   }
87754
87755   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87756   return jresult;
87757 }
87758
87759
87760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
87761   void * jresult ;
87762   Dali::Toolkit::ProgressBar *result = 0 ;
87763
87764   {
87765     try {
87766       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
87767     } catch (std::out_of_range& e) {
87768       {
87769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87770       };
87771     } catch (std::exception& e) {
87772       {
87773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87774       };
87775     } catch (Dali::DaliException e) {
87776       {
87777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87778       };
87779     } catch (...) {
87780       {
87781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87782       };
87783     }
87784   }
87785
87786   jresult = (void *)result;
87787   return jresult;
87788 }
87789
87790
87791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
87792   void * jresult ;
87793   Dali::Toolkit::ProgressBar *arg1 = 0 ;
87794   Dali::Toolkit::ProgressBar *result = 0 ;
87795
87796   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87797   if (!arg1) {
87798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87799     return 0;
87800   }
87801   {
87802     try {
87803       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
87804     } catch (std::out_of_range& e) {
87805       {
87806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87807       };
87808     } catch (std::exception& e) {
87809       {
87810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87811       };
87812     } catch (Dali::DaliException e) {
87813       {
87814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87815       };
87816     } catch (...) {
87817       {
87818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87819       };
87820     }
87821   }
87822
87823   jresult = (void *)result;
87824   return jresult;
87825 }
87826
87827
87828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
87829   void * jresult ;
87830   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87831   Dali::Toolkit::ProgressBar *arg2 = 0 ;
87832   Dali::Toolkit::ProgressBar *result = 0 ;
87833
87834   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87835   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
87836   if (!arg2) {
87837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87838     return 0;
87839   }
87840   {
87841     try {
87842       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
87843     } catch (std::out_of_range& e) {
87844       {
87845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87846       };
87847     } catch (std::exception& e) {
87848       {
87849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87850       };
87851     } catch (Dali::DaliException e) {
87852       {
87853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87854       };
87855     } catch (...) {
87856       {
87857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87858       };
87859     }
87860   }
87861
87862   jresult = (void *)result;
87863   return jresult;
87864 }
87865
87866
87867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
87868   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87869
87870   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87871   {
87872     try {
87873       delete arg1;
87874     } catch (std::out_of_range& e) {
87875       {
87876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87877       };
87878     } catch (std::exception& e) {
87879       {
87880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87881       };
87882     } catch (Dali::DaliException e) {
87883       {
87884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87885       };
87886     } catch (...) {
87887       {
87888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87889       };
87890     }
87891   }
87892
87893 }
87894
87895
87896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
87897   void * jresult ;
87898   Dali::BaseHandle arg1 ;
87899   Dali::BaseHandle *argp1 ;
87900   Dali::Toolkit::ProgressBar result;
87901
87902   argp1 = (Dali::BaseHandle *)jarg1;
87903   if (!argp1) {
87904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87905     return 0;
87906   }
87907   arg1 = *argp1;
87908   {
87909     try {
87910       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
87911     } catch (std::out_of_range& e) {
87912       {
87913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87914       };
87915     } catch (std::exception& e) {
87916       {
87917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87918       };
87919     } catch (Dali::DaliException e) {
87920       {
87921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87922       };
87923     } catch (...) {
87924       {
87925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87926       };
87927     }
87928   }
87929
87930   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87931   return jresult;
87932 }
87933
87934
87935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
87936   void * jresult ;
87937   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87938   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
87939
87940   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87941   {
87942     try {
87943       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87944     } catch (std::out_of_range& e) {
87945       {
87946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87947       };
87948     } catch (std::exception& e) {
87949       {
87950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87951       };
87952     } catch (Dali::DaliException e) {
87953       {
87954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87955       };
87956     } catch (...) {
87957       {
87958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87959       };
87960     }
87961   }
87962
87963   jresult = (void *)result;
87964   return jresult;
87965 }
87966
87967
87968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
87969   void * jresult ;
87970   Dali::Toolkit::GaussianBlurView *result = 0 ;
87971
87972   {
87973     try {
87974       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
87975     } catch (std::out_of_range& e) {
87976       {
87977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87978       };
87979     } catch (std::exception& e) {
87980       {
87981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87982       };
87983     } catch (Dali::DaliException e) {
87984       {
87985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87986       };
87987     } catch (...) {
87988       {
87989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87990       };
87991     }
87992   }
87993
87994   jresult = (void *)result;
87995   return jresult;
87996 }
87997
87998
87999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88000   void * jresult ;
88001   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88002   Dali::Toolkit::GaussianBlurView *result = 0 ;
88003
88004   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88005   if (!arg1) {
88006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88007     return 0;
88008   }
88009   {
88010     try {
88011       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88012     } catch (std::out_of_range& e) {
88013       {
88014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88015       };
88016     } catch (std::exception& e) {
88017       {
88018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88019       };
88020     } catch (Dali::DaliException e) {
88021       {
88022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88023       };
88024     } catch (...) {
88025       {
88026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88027       };
88028     }
88029   }
88030
88031   jresult = (void *)result;
88032   return jresult;
88033 }
88034
88035
88036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
88037   void * jresult ;
88038   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88039   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
88040   Dali::Toolkit::GaussianBlurView *result = 0 ;
88041
88042   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88043   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88044   if (!arg2) {
88045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88046     return 0;
88047   }
88048   {
88049     try {
88050       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
88051     } catch (std::out_of_range& e) {
88052       {
88053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88054       };
88055     } catch (std::exception& e) {
88056       {
88057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88058       };
88059     } catch (Dali::DaliException e) {
88060       {
88061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88062       };
88063     } catch (...) {
88064       {
88065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88066       };
88067     }
88068   }
88069
88070   jresult = (void *)result;
88071   return jresult;
88072 }
88073
88074
88075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
88076   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88077
88078   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88079   {
88080     try {
88081       delete arg1;
88082     } catch (std::out_of_range& e) {
88083       {
88084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88085       };
88086     } catch (std::exception& e) {
88087       {
88088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88089       };
88090     } catch (Dali::DaliException e) {
88091       {
88092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88093       };
88094     } catch (...) {
88095       {
88096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88097       };
88098     }
88099   }
88100
88101 }
88102
88103
88104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
88105   void * jresult ;
88106   Dali::BaseHandle arg1 ;
88107   Dali::BaseHandle *argp1 ;
88108   Dali::Toolkit::GaussianBlurView result;
88109
88110   argp1 = (Dali::BaseHandle *)jarg1;
88111   if (!argp1) {
88112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88113     return 0;
88114   }
88115   arg1 = *argp1;
88116   {
88117     try {
88118       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
88119     } catch (std::out_of_range& e) {
88120       {
88121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88122       };
88123     } catch (std::exception& e) {
88124       {
88125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88126       };
88127     } catch (Dali::DaliException e) {
88128       {
88129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88130       };
88131     } catch (...) {
88132       {
88133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88134       };
88135     }
88136   }
88137
88138   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88139   return jresult;
88140 }
88141
88142
88143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
88144   void * jresult ;
88145   Dali::Toolkit::GaussianBlurView result;
88146
88147   {
88148     try {
88149       result = Dali::Toolkit::GaussianBlurView::New();
88150     } catch (std::out_of_range& e) {
88151       {
88152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88153       };
88154     } catch (std::exception& e) {
88155       {
88156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88157       };
88158     } catch (Dali::DaliException e) {
88159       {
88160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88161       };
88162     } catch (...) {
88163       {
88164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88165       };
88166     }
88167   }
88168
88169   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88170   return jresult;
88171 }
88172
88173
88174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88175   void * jresult ;
88176   unsigned int arg1 ;
88177   float arg2 ;
88178   Dali::Pixel::Format arg3 ;
88179   float arg4 ;
88180   float arg5 ;
88181   bool arg6 ;
88182   Dali::Toolkit::GaussianBlurView result;
88183
88184   arg1 = (unsigned int)jarg1;
88185   arg2 = (float)jarg2;
88186   arg3 = (Dali::Pixel::Format)jarg3;
88187   arg4 = (float)jarg4;
88188   arg5 = (float)jarg5;
88189   arg6 = jarg6 ? true : false;
88190   {
88191     try {
88192       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88193     } catch (std::out_of_range& e) {
88194       {
88195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88196       };
88197     } catch (std::exception& e) {
88198       {
88199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88200       };
88201     } catch (Dali::DaliException e) {
88202       {
88203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88204       };
88205     } catch (...) {
88206       {
88207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88208       };
88209     }
88210   }
88211
88212   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88213   return jresult;
88214 }
88215
88216
88217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88218   void * jresult ;
88219   unsigned int arg1 ;
88220   float arg2 ;
88221   Dali::Pixel::Format arg3 ;
88222   float arg4 ;
88223   float arg5 ;
88224   Dali::Toolkit::GaussianBlurView result;
88225
88226   arg1 = (unsigned int)jarg1;
88227   arg2 = (float)jarg2;
88228   arg3 = (Dali::Pixel::Format)jarg3;
88229   arg4 = (float)jarg4;
88230   arg5 = (float)jarg5;
88231   {
88232     try {
88233       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
88234     } catch (std::out_of_range& e) {
88235       {
88236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88237       };
88238     } catch (std::exception& e) {
88239       {
88240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88241       };
88242     } catch (Dali::DaliException e) {
88243       {
88244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88245       };
88246     } catch (...) {
88247       {
88248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88249       };
88250     }
88251   }
88252
88253   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88254   return jresult;
88255 }
88256
88257
88258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
88259   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88260   Dali::Actor arg2 ;
88261   Dali::Actor *argp2 ;
88262
88263   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88264   argp2 = (Dali::Actor *)jarg2;
88265   if (!argp2) {
88266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88267     return ;
88268   }
88269   arg2 = *argp2;
88270   {
88271     try {
88272       (arg1)->Add(arg2);
88273     } catch (std::out_of_range& e) {
88274       {
88275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88276       };
88277     } catch (std::exception& e) {
88278       {
88279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88280       };
88281     } catch (Dali::DaliException e) {
88282       {
88283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88284       };
88285     } catch (...) {
88286       {
88287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88288       };
88289     }
88290   }
88291
88292 }
88293
88294
88295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
88296   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88297   Dali::Actor arg2 ;
88298   Dali::Actor *argp2 ;
88299
88300   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88301   argp2 = (Dali::Actor *)jarg2;
88302   if (!argp2) {
88303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88304     return ;
88305   }
88306   arg2 = *argp2;
88307   {
88308     try {
88309       (arg1)->Remove(arg2);
88310     } catch (std::out_of_range& e) {
88311       {
88312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88313       };
88314     } catch (std::exception& e) {
88315       {
88316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88317       };
88318     } catch (Dali::DaliException e) {
88319       {
88320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88321       };
88322     } catch (...) {
88323       {
88324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88325       };
88326     }
88327   }
88328
88329 }
88330
88331
88332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
88333   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88334
88335   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88336   {
88337     try {
88338       (arg1)->Activate();
88339     } catch (std::out_of_range& e) {
88340       {
88341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88342       };
88343     } catch (std::exception& e) {
88344       {
88345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88346       };
88347     } catch (Dali::DaliException e) {
88348       {
88349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88350       };
88351     } catch (...) {
88352       {
88353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88354       };
88355     }
88356   }
88357
88358 }
88359
88360
88361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
88362   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88363
88364   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88365   {
88366     try {
88367       (arg1)->ActivateOnce();
88368     } catch (std::out_of_range& e) {
88369       {
88370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88371       };
88372     } catch (std::exception& e) {
88373       {
88374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88375       };
88376     } catch (Dali::DaliException e) {
88377       {
88378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88379       };
88380     } catch (...) {
88381       {
88382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88383       };
88384     }
88385   }
88386
88387 }
88388
88389
88390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
88391   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88392
88393   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88394   {
88395     try {
88396       (arg1)->Deactivate();
88397     } catch (std::out_of_range& e) {
88398       {
88399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88400       };
88401     } catch (std::exception& e) {
88402       {
88403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88404       };
88405     } catch (Dali::DaliException e) {
88406       {
88407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88408       };
88409     } catch (...) {
88410       {
88411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88412       };
88413     }
88414   }
88415
88416 }
88417
88418
88419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
88420   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88421   Dali::Texture arg2 ;
88422   Dali::FrameBuffer arg3 ;
88423   Dali::Texture *argp2 ;
88424   Dali::FrameBuffer *argp3 ;
88425
88426   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88427   argp2 = (Dali::Texture *)jarg2;
88428   if (!argp2) {
88429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
88430     return ;
88431   }
88432   arg2 = *argp2;
88433   argp3 = (Dali::FrameBuffer *)jarg3;
88434   if (!argp3) {
88435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
88436     return ;
88437   }
88438   arg3 = *argp3;
88439   {
88440     try {
88441       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
88442     } catch (std::out_of_range& e) {
88443       {
88444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88445       };
88446     } catch (std::exception& e) {
88447       {
88448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88449       };
88450     } catch (Dali::DaliException e) {
88451       {
88452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88453       };
88454     } catch (...) {
88455       {
88456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88457       };
88458     }
88459   }
88460
88461 }
88462
88463
88464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
88465   int jresult ;
88466   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88467   Dali::Property::Index result;
88468
88469   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88470   {
88471     try {
88472       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
88473     } catch (std::out_of_range& e) {
88474       {
88475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88476       };
88477     } catch (std::exception& e) {
88478       {
88479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88480       };
88481     } catch (Dali::DaliException e) {
88482       {
88483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88484       };
88485     } catch (...) {
88486       {
88487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88488       };
88489     }
88490   }
88491
88492   jresult = result;
88493   return jresult;
88494 }
88495
88496
88497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
88498   void * jresult ;
88499   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88500   Dali::FrameBuffer result;
88501
88502   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88503   {
88504     try {
88505       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
88506     } catch (std::out_of_range& e) {
88507       {
88508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88509       };
88510     } catch (std::exception& e) {
88511       {
88512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88513       };
88514     } catch (Dali::DaliException e) {
88515       {
88516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88517       };
88518     } catch (...) {
88519       {
88520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88521       };
88522     }
88523   }
88524
88525   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
88526   return jresult;
88527 }
88528
88529
88530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
88531   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88532   Dali::Vector4 *arg2 = 0 ;
88533
88534   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88535   arg2 = (Dali::Vector4 *)jarg2;
88536   if (!arg2) {
88537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
88538     return ;
88539   }
88540   {
88541     try {
88542       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
88543     } catch (std::out_of_range& e) {
88544       {
88545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88546       };
88547     } catch (std::exception& e) {
88548       {
88549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88550       };
88551     } catch (Dali::DaliException e) {
88552       {
88553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88554       };
88555     } catch (...) {
88556       {
88557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88558       };
88559     }
88560   }
88561
88562 }
88563
88564
88565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
88566   void * jresult ;
88567   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88568   Dali::Vector4 result;
88569
88570   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88571   {
88572     try {
88573       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
88574     } catch (std::out_of_range& e) {
88575       {
88576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88577       };
88578     } catch (std::exception& e) {
88579       {
88580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88581       };
88582     } catch (Dali::DaliException e) {
88583       {
88584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88585       };
88586     } catch (...) {
88587       {
88588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88589       };
88590     }
88591   }
88592
88593   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
88594   return jresult;
88595 }
88596
88597
88598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
88599   void * jresult ;
88600   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88601   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
88602
88603   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88604   {
88605     try {
88606       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
88607     } catch (std::out_of_range& e) {
88608       {
88609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88610       };
88611     } catch (std::exception& e) {
88612       {
88613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88614       };
88615     } catch (Dali::DaliException e) {
88616       {
88617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88618       };
88619     } catch (...) {
88620       {
88621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88622       };
88623     }
88624   }
88625
88626   jresult = (void *)result;
88627   return jresult;
88628 }
88629
88630
88631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
88632   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88633
88634   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88635   {
88636     try {
88637       delete arg1;
88638     } catch (std::out_of_range& e) {
88639       {
88640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88641       };
88642     } catch (std::exception& e) {
88643       {
88644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88645       };
88646     } catch (Dali::DaliException e) {
88647       {
88648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88649       };
88650     } catch (...) {
88651       {
88652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88653       };
88654     }
88655   }
88656
88657 }
88658
88659
88660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
88661   unsigned int jresult ;
88662   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88663   unsigned int result;
88664
88665   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88666   {
88667     try {
88668       result = (unsigned int)(arg1)->GetNumberOfPages();
88669     } catch (std::out_of_range& e) {
88670       {
88671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88672       };
88673     } catch (std::exception& e) {
88674       {
88675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88676       };
88677     } catch (Dali::DaliException e) {
88678       {
88679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88680       };
88681     } catch (...) {
88682       {
88683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88684       };
88685     }
88686   }
88687
88688   jresult = result;
88689   return jresult;
88690 }
88691
88692
88693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
88694   void * jresult ;
88695   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88696   unsigned int arg2 ;
88697   Dali::Texture result;
88698
88699   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88700   arg2 = (unsigned int)jarg2;
88701   {
88702     try {
88703       result = (arg1)->NewPage(arg2);
88704     } catch (std::out_of_range& e) {
88705       {
88706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88707       };
88708     } catch (std::exception& e) {
88709       {
88710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88711       };
88712     } catch (Dali::DaliException e) {
88713       {
88714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88715       };
88716     } catch (...) {
88717       {
88718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88719       };
88720     }
88721   }
88722
88723   jresult = new Dali::Texture((const Dali::Texture &)result);
88724   return jresult;
88725 }
88726
88727
88728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
88729   int jresult ;
88730   int result;
88731
88732   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
88733   jresult = (int)result;
88734   return jresult;
88735 }
88736
88737
88738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
88739   int jresult ;
88740   int result;
88741
88742   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
88743   jresult = (int)result;
88744   return jresult;
88745 }
88746
88747
88748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
88749   int jresult ;
88750   int result;
88751
88752   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
88753   jresult = (int)result;
88754   return jresult;
88755 }
88756
88757
88758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
88759   void * jresult ;
88760   Dali::Toolkit::PageTurnView::Property *result = 0 ;
88761
88762   {
88763     try {
88764       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
88765     } catch (std::out_of_range& e) {
88766       {
88767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88768       };
88769     } catch (std::exception& e) {
88770       {
88771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88772       };
88773     } catch (Dali::DaliException e) {
88774       {
88775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88776       };
88777     } catch (...) {
88778       {
88779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88780       };
88781     }
88782   }
88783
88784   jresult = (void *)result;
88785   return jresult;
88786 }
88787
88788
88789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
88790   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
88791
88792   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
88793   {
88794     try {
88795       delete arg1;
88796     } catch (std::out_of_range& e) {
88797       {
88798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88799       };
88800     } catch (std::exception& e) {
88801       {
88802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88803       };
88804     } catch (Dali::DaliException e) {
88805       {
88806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88807       };
88808     } catch (...) {
88809       {
88810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88811       };
88812     }
88813   }
88814
88815 }
88816
88817
88818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
88819   void * jresult ;
88820   Dali::Toolkit::PageTurnView *result = 0 ;
88821
88822   {
88823     try {
88824       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
88825     } catch (std::out_of_range& e) {
88826       {
88827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88828       };
88829     } catch (std::exception& e) {
88830       {
88831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88832       };
88833     } catch (Dali::DaliException e) {
88834       {
88835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88836       };
88837     } catch (...) {
88838       {
88839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88840       };
88841     }
88842   }
88843
88844   jresult = (void *)result;
88845   return jresult;
88846 }
88847
88848
88849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
88850   void * jresult ;
88851   Dali::Toolkit::PageTurnView *arg1 = 0 ;
88852   Dali::Toolkit::PageTurnView *result = 0 ;
88853
88854   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88855   if (!arg1) {
88856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88857     return 0;
88858   }
88859   {
88860     try {
88861       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
88862     } catch (std::out_of_range& e) {
88863       {
88864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88865       };
88866     } catch (std::exception& e) {
88867       {
88868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88869       };
88870     } catch (Dali::DaliException e) {
88871       {
88872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88873       };
88874     } catch (...) {
88875       {
88876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88877       };
88878     }
88879   }
88880
88881   jresult = (void *)result;
88882   return jresult;
88883 }
88884
88885
88886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
88887   void * jresult ;
88888   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88889   Dali::Toolkit::PageTurnView *arg2 = 0 ;
88890   Dali::Toolkit::PageTurnView *result = 0 ;
88891
88892   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88893   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
88894   if (!arg2) {
88895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88896     return 0;
88897   }
88898   {
88899     try {
88900       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
88901     } catch (std::out_of_range& e) {
88902       {
88903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88904       };
88905     } catch (std::exception& e) {
88906       {
88907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88908       };
88909     } catch (Dali::DaliException e) {
88910       {
88911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88912       };
88913     } catch (...) {
88914       {
88915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88916       };
88917     }
88918   }
88919
88920   jresult = (void *)result;
88921   return jresult;
88922 }
88923
88924
88925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
88926   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88927
88928   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88929   {
88930     try {
88931       delete arg1;
88932     } catch (std::out_of_range& e) {
88933       {
88934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88935       };
88936     } catch (std::exception& e) {
88937       {
88938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88939       };
88940     } catch (Dali::DaliException e) {
88941       {
88942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88943       };
88944     } catch (...) {
88945       {
88946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88947       };
88948     }
88949   }
88950
88951 }
88952
88953
88954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
88955   void * jresult ;
88956   Dali::BaseHandle arg1 ;
88957   Dali::BaseHandle *argp1 ;
88958   Dali::Toolkit::PageTurnView result;
88959
88960   argp1 = (Dali::BaseHandle *)jarg1;
88961   if (!argp1) {
88962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88963     return 0;
88964   }
88965   arg1 = *argp1;
88966   {
88967     try {
88968       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
88969     } catch (std::out_of_range& e) {
88970       {
88971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88972       };
88973     } catch (std::exception& e) {
88974       {
88975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88976       };
88977     } catch (Dali::DaliException e) {
88978       {
88979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88980       };
88981     } catch (...) {
88982       {
88983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88984       };
88985     }
88986   }
88987
88988   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
88989   return jresult;
88990 }
88991
88992
88993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
88994   void * jresult ;
88995   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88996   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88997
88998   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88999   {
89000     try {
89001       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89002     } catch (std::out_of_range& e) {
89003       {
89004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89005       };
89006     } catch (std::exception& e) {
89007       {
89008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89009       };
89010     } catch (Dali::DaliException e) {
89011       {
89012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89013       };
89014     } catch (...) {
89015       {
89016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89017       };
89018     }
89019   }
89020
89021   jresult = (void *)result;
89022   return jresult;
89023 }
89024
89025
89026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
89027   void * jresult ;
89028   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89029   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89030
89031   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89032   {
89033     try {
89034       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
89035     } catch (std::out_of_range& e) {
89036       {
89037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89038       };
89039     } catch (std::exception& e) {
89040       {
89041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89042       };
89043     } catch (Dali::DaliException e) {
89044       {
89045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89046       };
89047     } catch (...) {
89048       {
89049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89050       };
89051     }
89052   }
89053
89054   jresult = (void *)result;
89055   return jresult;
89056 }
89057
89058
89059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
89060   void * jresult ;
89061   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89062   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89063
89064   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89065   {
89066     try {
89067       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
89068     } catch (std::out_of_range& e) {
89069       {
89070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89071       };
89072     } catch (std::exception& e) {
89073       {
89074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89075       };
89076     } catch (Dali::DaliException e) {
89077       {
89078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89079       };
89080     } catch (...) {
89081       {
89082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89083       };
89084     }
89085   }
89086
89087   jresult = (void *)result;
89088   return jresult;
89089 }
89090
89091
89092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
89093   void * jresult ;
89094   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89095   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89096
89097   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89098   {
89099     try {
89100       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
89101     } catch (std::out_of_range& e) {
89102       {
89103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89104       };
89105     } catch (std::exception& e) {
89106       {
89107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89108       };
89109     } catch (Dali::DaliException e) {
89110       {
89111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89112       };
89113     } catch (...) {
89114       {
89115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89116       };
89117     }
89118   }
89119
89120   jresult = (void *)result;
89121   return jresult;
89122 }
89123
89124
89125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
89126   void * jresult ;
89127   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89128
89129   {
89130     try {
89131       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
89132     } catch (std::out_of_range& e) {
89133       {
89134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89135       };
89136     } catch (std::exception& e) {
89137       {
89138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89139       };
89140     } catch (Dali::DaliException e) {
89141       {
89142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89143       };
89144     } catch (...) {
89145       {
89146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89147       };
89148     }
89149   }
89150
89151   jresult = (void *)result;
89152   return jresult;
89153 }
89154
89155
89156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89157   void * jresult ;
89158   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89159   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89160
89161   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89162   if (!arg1) {
89163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89164     return 0;
89165   }
89166   {
89167     try {
89168       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89169     } catch (std::out_of_range& e) {
89170       {
89171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89172       };
89173     } catch (std::exception& e) {
89174       {
89175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89176       };
89177     } catch (Dali::DaliException e) {
89178       {
89179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89180       };
89181     } catch (...) {
89182       {
89183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89184       };
89185     }
89186   }
89187
89188   jresult = (void *)result;
89189   return jresult;
89190 }
89191
89192
89193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89194   void * jresult ;
89195   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89196   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89197   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89198
89199   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89200   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89201   if (!arg2) {
89202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89203     return 0;
89204   }
89205   {
89206     try {
89207       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89208     } catch (std::out_of_range& e) {
89209       {
89210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89211       };
89212     } catch (std::exception& e) {
89213       {
89214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89215       };
89216     } catch (Dali::DaliException e) {
89217       {
89218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89219       };
89220     } catch (...) {
89221       {
89222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89223       };
89224     }
89225   }
89226
89227   jresult = (void *)result;
89228   return jresult;
89229 }
89230
89231
89232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
89233   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89234
89235   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89236   {
89237     try {
89238       delete arg1;
89239     } catch (std::out_of_range& e) {
89240       {
89241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89242       };
89243     } catch (std::exception& e) {
89244       {
89245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89246       };
89247     } catch (Dali::DaliException e) {
89248       {
89249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89250       };
89251     } catch (...) {
89252       {
89253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89254       };
89255     }
89256   }
89257
89258 }
89259
89260
89261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
89262   void * jresult ;
89263   Dali::Toolkit::PageFactory *arg1 = 0 ;
89264   Dali::Vector2 *arg2 = 0 ;
89265   Dali::Toolkit::PageTurnLandscapeView result;
89266
89267   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89268   if (!arg1) {
89269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89270     return 0;
89271   }
89272   arg2 = (Dali::Vector2 *)jarg2;
89273   if (!arg2) {
89274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89275     return 0;
89276   }
89277   {
89278     try {
89279       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
89280     } catch (std::out_of_range& e) {
89281       {
89282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89283       };
89284     } catch (std::exception& e) {
89285       {
89286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89287       };
89288     } catch (Dali::DaliException e) {
89289       {
89290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89291       };
89292     } catch (...) {
89293       {
89294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89295       };
89296     }
89297   }
89298
89299   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89300   return jresult;
89301 }
89302
89303
89304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
89305   void * jresult ;
89306   Dali::BaseHandle arg1 ;
89307   Dali::BaseHandle *argp1 ;
89308   Dali::Toolkit::PageTurnLandscapeView result;
89309
89310   argp1 = (Dali::BaseHandle *)jarg1;
89311   if (!argp1) {
89312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89313     return 0;
89314   }
89315   arg1 = *argp1;
89316   {
89317     try {
89318       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
89319     } catch (std::out_of_range& e) {
89320       {
89321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89322       };
89323     } catch (std::exception& e) {
89324       {
89325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89326       };
89327     } catch (Dali::DaliException e) {
89328       {
89329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89330       };
89331     } catch (...) {
89332       {
89333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89334       };
89335     }
89336   }
89337
89338   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89339   return jresult;
89340 }
89341
89342
89343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
89344   void * jresult ;
89345   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89346
89347   {
89348     try {
89349       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
89350     } catch (std::out_of_range& e) {
89351       {
89352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89353       };
89354     } catch (std::exception& e) {
89355       {
89356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89357       };
89358     } catch (Dali::DaliException e) {
89359       {
89360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89361       };
89362     } catch (...) {
89363       {
89364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89365       };
89366     }
89367   }
89368
89369   jresult = (void *)result;
89370   return jresult;
89371 }
89372
89373
89374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
89375   void * jresult ;
89376   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
89377   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89378
89379   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89380   if (!arg1) {
89381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89382     return 0;
89383   }
89384   {
89385     try {
89386       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
89387     } catch (std::out_of_range& e) {
89388       {
89389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89390       };
89391     } catch (std::exception& e) {
89392       {
89393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89394       };
89395     } catch (Dali::DaliException e) {
89396       {
89397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89398       };
89399     } catch (...) {
89400       {
89401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89402       };
89403     }
89404   }
89405
89406   jresult = (void *)result;
89407   return jresult;
89408 }
89409
89410
89411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
89412   void * jresult ;
89413   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89414   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
89415   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89416
89417   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89418   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
89419   if (!arg2) {
89420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89421     return 0;
89422   }
89423   {
89424     try {
89425       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
89426     } catch (std::out_of_range& e) {
89427       {
89428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89429       };
89430     } catch (std::exception& e) {
89431       {
89432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89433       };
89434     } catch (Dali::DaliException e) {
89435       {
89436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89437       };
89438     } catch (...) {
89439       {
89440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89441       };
89442     }
89443   }
89444
89445   jresult = (void *)result;
89446   return jresult;
89447 }
89448
89449
89450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
89451   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89452
89453   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89454   {
89455     try {
89456       delete arg1;
89457     } catch (std::out_of_range& e) {
89458       {
89459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89460       };
89461     } catch (std::exception& e) {
89462       {
89463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89464       };
89465     } catch (Dali::DaliException e) {
89466       {
89467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89468       };
89469     } catch (...) {
89470       {
89471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89472       };
89473     }
89474   }
89475
89476 }
89477
89478
89479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
89480   void * jresult ;
89481   Dali::Toolkit::PageFactory *arg1 = 0 ;
89482   Dali::Vector2 *arg2 = 0 ;
89483   Dali::Toolkit::PageTurnPortraitView result;
89484
89485   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89486   if (!arg1) {
89487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89488     return 0;
89489   }
89490   arg2 = (Dali::Vector2 *)jarg2;
89491   if (!arg2) {
89492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89493     return 0;
89494   }
89495   {
89496     try {
89497       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
89498     } catch (std::out_of_range& e) {
89499       {
89500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89501       };
89502     } catch (std::exception& e) {
89503       {
89504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89505       };
89506     } catch (Dali::DaliException e) {
89507       {
89508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89509       };
89510     } catch (...) {
89511       {
89512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89513       };
89514     }
89515   }
89516
89517   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89518   return jresult;
89519 }
89520
89521
89522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
89523   void * jresult ;
89524   Dali::BaseHandle arg1 ;
89525   Dali::BaseHandle *argp1 ;
89526   Dali::Toolkit::PageTurnPortraitView result;
89527
89528   argp1 = (Dali::BaseHandle *)jarg1;
89529   if (!argp1) {
89530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89531     return 0;
89532   }
89533   arg1 = *argp1;
89534   {
89535     try {
89536       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
89537     } catch (std::out_of_range& e) {
89538       {
89539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89540       };
89541     } catch (std::exception& e) {
89542       {
89543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89544       };
89545     } catch (Dali::DaliException e) {
89546       {
89547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89548       };
89549     } catch (...) {
89550       {
89551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89552       };
89553     }
89554   }
89555
89556   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89557   return jresult;
89558 }
89559
89560
89561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
89562   int jresult ;
89563   int result;
89564
89565   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
89566   jresult = (int)result;
89567   return jresult;
89568 }
89569
89570
89571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
89572   int jresult ;
89573   int result;
89574
89575   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
89576   jresult = (int)result;
89577   return jresult;
89578 }
89579
89580
89581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
89582   int jresult ;
89583   int result;
89584
89585   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
89586   jresult = (int)result;
89587   return jresult;
89588 }
89589
89590
89591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
89592   void * jresult ;
89593   Dali::Toolkit::ToggleButton::Property *result = 0 ;
89594
89595   {
89596     try {
89597       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
89598     } catch (std::out_of_range& e) {
89599       {
89600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89601       };
89602     } catch (std::exception& e) {
89603       {
89604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89605       };
89606     } catch (Dali::DaliException e) {
89607       {
89608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89609       };
89610     } catch (...) {
89611       {
89612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89613       };
89614     }
89615   }
89616
89617   jresult = (void *)result;
89618   return jresult;
89619 }
89620
89621
89622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
89623   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
89624
89625   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
89626   {
89627     try {
89628       delete arg1;
89629     } catch (std::out_of_range& e) {
89630       {
89631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89632       };
89633     } catch (std::exception& e) {
89634       {
89635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89636       };
89637     } catch (Dali::DaliException e) {
89638       {
89639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89640       };
89641     } catch (...) {
89642       {
89643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89644       };
89645     }
89646   }
89647
89648 }
89649
89650
89651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
89652   void * jresult ;
89653   Dali::Toolkit::ToggleButton *result = 0 ;
89654
89655   {
89656     try {
89657       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
89658     } catch (std::out_of_range& e) {
89659       {
89660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89661       };
89662     } catch (std::exception& e) {
89663       {
89664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89665       };
89666     } catch (Dali::DaliException e) {
89667       {
89668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89669       };
89670     } catch (...) {
89671       {
89672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89673       };
89674     }
89675   }
89676
89677   jresult = (void *)result;
89678   return jresult;
89679 }
89680
89681
89682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
89683   void * jresult ;
89684   Dali::Toolkit::ToggleButton *arg1 = 0 ;
89685   Dali::Toolkit::ToggleButton *result = 0 ;
89686
89687   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89688   if (!arg1) {
89689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89690     return 0;
89691   }
89692   {
89693     try {
89694       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
89695     } catch (std::out_of_range& e) {
89696       {
89697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89698       };
89699     } catch (std::exception& e) {
89700       {
89701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89702       };
89703     } catch (Dali::DaliException e) {
89704       {
89705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89706       };
89707     } catch (...) {
89708       {
89709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89710       };
89711     }
89712   }
89713
89714   jresult = (void *)result;
89715   return jresult;
89716 }
89717
89718
89719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
89720   void * jresult ;
89721   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89722   Dali::Toolkit::ToggleButton *arg2 = 0 ;
89723   Dali::Toolkit::ToggleButton *result = 0 ;
89724
89725   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89726   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
89727   if (!arg2) {
89728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89729     return 0;
89730   }
89731   {
89732     try {
89733       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
89734     } catch (std::out_of_range& e) {
89735       {
89736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89737       };
89738     } catch (std::exception& e) {
89739       {
89740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89741       };
89742     } catch (Dali::DaliException e) {
89743       {
89744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89745       };
89746     } catch (...) {
89747       {
89748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89749       };
89750     }
89751   }
89752
89753   jresult = (void *)result;
89754   return jresult;
89755 }
89756
89757
89758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
89759   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89760
89761   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89762   {
89763     try {
89764       delete arg1;
89765     } catch (std::out_of_range& e) {
89766       {
89767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89768       };
89769     } catch (std::exception& e) {
89770       {
89771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89772       };
89773     } catch (Dali::DaliException e) {
89774       {
89775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89776       };
89777     } catch (...) {
89778       {
89779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89780       };
89781     }
89782   }
89783
89784 }
89785
89786
89787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
89788   void * jresult ;
89789   Dali::Toolkit::ToggleButton result;
89790
89791   {
89792     try {
89793       result = Dali::Toolkit::ToggleButton::New();
89794     } catch (std::out_of_range& e) {
89795       {
89796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89797       };
89798     } catch (std::exception& e) {
89799       {
89800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89801       };
89802     } catch (Dali::DaliException e) {
89803       {
89804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89805       };
89806     } catch (...) {
89807       {
89808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89809       };
89810     }
89811   }
89812
89813   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89814   return jresult;
89815 }
89816
89817
89818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
89819   void * jresult ;
89820   Dali::BaseHandle arg1 ;
89821   Dali::BaseHandle *argp1 ;
89822   Dali::Toolkit::ToggleButton result;
89823
89824   argp1 = (Dali::BaseHandle *)jarg1;
89825   if (!argp1) {
89826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89827     return 0;
89828   }
89829   arg1 = *argp1;
89830   {
89831     try {
89832       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
89833     } catch (std::out_of_range& e) {
89834       {
89835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89836       };
89837     } catch (std::exception& e) {
89838       {
89839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89840       };
89841     } catch (Dali::DaliException e) {
89842       {
89843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89844       };
89845     } catch (...) {
89846       {
89847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89848       };
89849     }
89850   }
89851
89852   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89853   return jresult;
89854 }
89855
89856
89857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
89858   void * jresult ;
89859   Dali::Toolkit::Visual::Base *result = 0 ;
89860
89861   {
89862     try {
89863       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
89864     } catch (std::out_of_range& e) {
89865       {
89866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89867       };
89868     } catch (std::exception& e) {
89869       {
89870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89871       };
89872     } catch (Dali::DaliException e) {
89873       {
89874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89875       };
89876     } catch (...) {
89877       {
89878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89879       };
89880     }
89881   }
89882
89883   jresult = (void *)result;
89884   return jresult;
89885 }
89886
89887
89888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
89889   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89890
89891   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89892   {
89893     try {
89894       delete arg1;
89895     } catch (std::out_of_range& e) {
89896       {
89897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89898       };
89899     } catch (std::exception& e) {
89900       {
89901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89902       };
89903     } catch (Dali::DaliException e) {
89904       {
89905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89906       };
89907     } catch (...) {
89908       {
89909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89910       };
89911     }
89912   }
89913
89914 }
89915
89916
89917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
89918   void * jresult ;
89919   Dali::Toolkit::Visual::Base *arg1 = 0 ;
89920   Dali::Toolkit::Visual::Base *result = 0 ;
89921
89922   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89923   if (!arg1) {
89924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89925     return 0;
89926   }
89927   {
89928     try {
89929       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
89930     } catch (std::out_of_range& e) {
89931       {
89932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89933       };
89934     } catch (std::exception& e) {
89935       {
89936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89937       };
89938     } catch (Dali::DaliException e) {
89939       {
89940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89941       };
89942     } catch (...) {
89943       {
89944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89945       };
89946     }
89947   }
89948
89949   jresult = (void *)result;
89950   return jresult;
89951 }
89952
89953
89954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
89955   void * jresult ;
89956   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89957   Dali::Toolkit::Visual::Base *arg2 = 0 ;
89958   Dali::Toolkit::Visual::Base *result = 0 ;
89959
89960   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89961   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
89962   if (!arg2) {
89963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89964     return 0;
89965   }
89966   {
89967     try {
89968       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
89969     } catch (std::out_of_range& e) {
89970       {
89971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89972       };
89973     } catch (std::exception& e) {
89974       {
89975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89976       };
89977     } catch (Dali::DaliException e) {
89978       {
89979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89980       };
89981     } catch (...) {
89982       {
89983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89984       };
89985     }
89986   }
89987
89988   jresult = (void *)result;
89989   return jresult;
89990 }
89991
89992
89993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
89994   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89995   std::string *arg2 = 0 ;
89996
89997   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89998   if (!jarg2) {
89999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90000     return ;
90001   }
90002   std::string arg2_str(jarg2);
90003   arg2 = &arg2_str;
90004   {
90005     try {
90006       (arg1)->SetName((std::string const &)*arg2);
90007     } catch (std::out_of_range& e) {
90008       {
90009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90010       };
90011     } catch (std::exception& e) {
90012       {
90013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90014       };
90015     } catch (Dali::DaliException e) {
90016       {
90017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90018       };
90019     } catch (...) {
90020       {
90021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90022       };
90023     }
90024   }
90025
90026
90027   //argout typemap for const std::string&
90028
90029 }
90030
90031
90032 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
90033   char * jresult ;
90034   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90035   std::string *result = 0 ;
90036
90037   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90038   {
90039     try {
90040       result = (std::string *) &(arg1)->GetName();
90041     } catch (std::out_of_range& e) {
90042       {
90043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90044       };
90045     } catch (std::exception& e) {
90046       {
90047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90048       };
90049     } catch (Dali::DaliException e) {
90050       {
90051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90052       };
90053     } catch (...) {
90054       {
90055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90056       };
90057     }
90058   }
90059
90060   jresult = SWIG_csharp_string_callback(result->c_str());
90061   return jresult;
90062 }
90063
90064
90065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
90066   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90067   Dali::Property::Map *arg2 = 0 ;
90068   Dali::Size arg3 ;
90069   Dali::Size *argp3 ;
90070
90071   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90072   arg2 = (Dali::Property::Map *)jarg2;
90073   if (!arg2) {
90074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90075     return ;
90076   }
90077   argp3 = (Dali::Size *)jarg3;
90078   if (!argp3) {
90079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
90080     return ;
90081   }
90082   arg3 = *argp3;
90083   {
90084     try {
90085       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
90086     } catch (std::out_of_range& e) {
90087       {
90088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90089       };
90090     } catch (std::exception& e) {
90091       {
90092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90093       };
90094     } catch (Dali::DaliException e) {
90095       {
90096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90097       };
90098     } catch (...) {
90099       {
90100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90101       };
90102     }
90103   }
90104
90105 }
90106
90107
90108 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
90109   float jresult ;
90110   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90111   float arg2 ;
90112   float result;
90113
90114   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90115   arg2 = (float)jarg2;
90116   {
90117     try {
90118       result = (float)(arg1)->GetHeightForWidth(arg2);
90119     } catch (std::out_of_range& e) {
90120       {
90121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90122       };
90123     } catch (std::exception& e) {
90124       {
90125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90126       };
90127     } catch (Dali::DaliException e) {
90128       {
90129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90130       };
90131     } catch (...) {
90132       {
90133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90134       };
90135     }
90136   }
90137
90138   jresult = result;
90139   return jresult;
90140 }
90141
90142
90143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
90144   float jresult ;
90145   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90146   float arg2 ;
90147   float result;
90148
90149   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90150   arg2 = (float)jarg2;
90151   {
90152     try {
90153       result = (float)(arg1)->GetWidthForHeight(arg2);
90154     } catch (std::out_of_range& e) {
90155       {
90156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90157       };
90158     } catch (std::exception& e) {
90159       {
90160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90161       };
90162     } catch (Dali::DaliException e) {
90163       {
90164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90165       };
90166     } catch (...) {
90167       {
90168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90169       };
90170     }
90171   }
90172
90173   jresult = result;
90174   return jresult;
90175 }
90176
90177
90178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90179   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90180   Dali::Vector2 *arg2 = 0 ;
90181
90182   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90183   arg2 = (Dali::Vector2 *)jarg2;
90184   if (!arg2) {
90185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90186     return ;
90187   }
90188   {
90189     try {
90190       (arg1)->GetNaturalSize(*arg2);
90191     } catch (std::out_of_range& e) {
90192       {
90193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90194       };
90195     } catch (std::exception& e) {
90196       {
90197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90198       };
90199     } catch (Dali::DaliException e) {
90200       {
90201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90202       };
90203     } catch (...) {
90204       {
90205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90206       };
90207     }
90208   }
90209
90210 }
90211
90212
90213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90214   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90215   float arg2 ;
90216
90217   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90218   arg2 = (int)jarg2;
90219   {
90220     try {
90221       (arg1)->SetDepthIndex(arg2);
90222     } catch (std::out_of_range& e) {
90223       {
90224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90225       };
90226     } catch (std::exception& e) {
90227       {
90228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90229       };
90230     } catch (Dali::DaliException e) {
90231       {
90232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90233       };
90234     } catch (...) {
90235       {
90236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90237       };
90238     }
90239   }
90240
90241 }
90242
90243
90244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
90245   int jresult ;
90246   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90247   int result;
90248
90249   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90250   {
90251     try {
90252       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
90253     } catch (std::out_of_range& e) {
90254       {
90255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90256       };
90257     } catch (std::exception& e) {
90258       {
90259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90260       };
90261     } catch (Dali::DaliException e) {
90262       {
90263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90264       };
90265     } catch (...) {
90266       {
90267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90268       };
90269     }
90270   }
90271
90272   jresult = result;
90273   return jresult;
90274 }
90275
90276
90277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
90278   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90279   Dali::Property::Map *arg2 = 0 ;
90280
90281   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90282   arg2 = (Dali::Property::Map *)jarg2;
90283   if (!arg2) {
90284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
90285     return ;
90286   }
90287   {
90288     try {
90289       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
90290     } catch (std::out_of_range& e) {
90291       {
90292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90293       };
90294     } catch (std::exception& e) {
90295       {
90296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90297       };
90298     } catch (Dali::DaliException e) {
90299       {
90300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90301       };
90302     } catch (...) {
90303       {
90304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90305       };
90306     }
90307   }
90308
90309 }
90310
90311
90312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
90313   void * jresult ;
90314   Dali::Toolkit::VisualFactory result;
90315
90316   {
90317     try {
90318       result = Dali::Toolkit::VisualFactory::Get();
90319     } catch (std::out_of_range& e) {
90320       {
90321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90322       };
90323     } catch (std::exception& e) {
90324       {
90325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90326       };
90327     } catch (Dali::DaliException e) {
90328       {
90329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90330       };
90331     } catch (...) {
90332       {
90333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90334       };
90335     }
90336   }
90337
90338   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
90339   return jresult;
90340 }
90341
90342
90343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
90344   void * jresult ;
90345   Dali::Toolkit::VisualFactory *result = 0 ;
90346
90347   {
90348     try {
90349       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
90350     } catch (std::out_of_range& e) {
90351       {
90352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90353       };
90354     } catch (std::exception& e) {
90355       {
90356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90357       };
90358     } catch (Dali::DaliException e) {
90359       {
90360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90361       };
90362     } catch (...) {
90363       {
90364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90365       };
90366     }
90367   }
90368
90369   jresult = (void *)result;
90370   return jresult;
90371 }
90372
90373
90374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
90375   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90376
90377   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90378   {
90379     try {
90380       delete arg1;
90381     } catch (std::out_of_range& e) {
90382       {
90383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90384       };
90385     } catch (std::exception& e) {
90386       {
90387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90388       };
90389     } catch (Dali::DaliException e) {
90390       {
90391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90392       };
90393     } catch (...) {
90394       {
90395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90396       };
90397     }
90398   }
90399
90400 }
90401
90402
90403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
90404   void * jresult ;
90405   Dali::Toolkit::VisualFactory *arg1 = 0 ;
90406   Dali::Toolkit::VisualFactory *result = 0 ;
90407
90408   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90409   if (!arg1) {
90410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90411     return 0;
90412   }
90413   {
90414     try {
90415       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
90416     } catch (std::out_of_range& e) {
90417       {
90418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90419       };
90420     } catch (std::exception& e) {
90421       {
90422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90423       };
90424     } catch (Dali::DaliException e) {
90425       {
90426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90427       };
90428     } catch (...) {
90429       {
90430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90431       };
90432     }
90433   }
90434
90435   jresult = (void *)result;
90436   return jresult;
90437 }
90438
90439
90440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
90441   void * jresult ;
90442   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90443   Dali::Toolkit::VisualFactory *arg2 = 0 ;
90444   Dali::Toolkit::VisualFactory *result = 0 ;
90445
90446   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90447   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
90448   if (!arg2) {
90449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90450     return 0;
90451   }
90452   {
90453     try {
90454       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
90455     } catch (std::out_of_range& e) {
90456       {
90457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90458       };
90459     } catch (std::exception& e) {
90460       {
90461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90462       };
90463     } catch (Dali::DaliException e) {
90464       {
90465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90466       };
90467     } catch (...) {
90468       {
90469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90470       };
90471     }
90472   }
90473
90474   jresult = (void *)result;
90475   return jresult;
90476 }
90477
90478
90479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
90480   void * jresult ;
90481   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90482   Dali::Property::Map *arg2 = 0 ;
90483   Dali::Toolkit::Visual::Base result;
90484
90485   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90486   arg2 = (Dali::Property::Map *)jarg2;
90487   if (!arg2) {
90488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90489     return 0;
90490   }
90491   {
90492     try {
90493       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
90494     } catch (std::out_of_range& e) {
90495       {
90496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90497       };
90498     } catch (std::exception& e) {
90499       {
90500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90501       };
90502     } catch (Dali::DaliException e) {
90503       {
90504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90505       };
90506     } catch (...) {
90507       {
90508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90509       };
90510     }
90511   }
90512
90513   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90514   return jresult;
90515 }
90516
90517
90518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
90519   void * jresult ;
90520   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90521   Dali::Image *arg2 = 0 ;
90522   Dali::Toolkit::Visual::Base result;
90523
90524   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90525   arg2 = (Dali::Image *)jarg2;
90526   if (!arg2) {
90527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
90528     return 0;
90529   }
90530   {
90531     try {
90532       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
90533     } catch (std::out_of_range& e) {
90534       {
90535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90536       };
90537     } catch (std::exception& e) {
90538       {
90539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90540       };
90541     } catch (Dali::DaliException e) {
90542       {
90543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90544       };
90545     } catch (...) {
90546       {
90547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90548       };
90549     }
90550   }
90551
90552   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90553   return jresult;
90554 }
90555
90556
90557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
90558   void * jresult ;
90559   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90560   std::string *arg2 = 0 ;
90561   Dali::ImageDimensions arg3 ;
90562   Dali::ImageDimensions *argp3 ;
90563   Dali::Toolkit::Visual::Base result;
90564
90565   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90566   if (!jarg2) {
90567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90568     return 0;
90569   }
90570   std::string arg2_str(jarg2);
90571   arg2 = &arg2_str;
90572   argp3 = (Dali::ImageDimensions *)jarg3;
90573   if (!argp3) {
90574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90575     return 0;
90576   }
90577   arg3 = *argp3;
90578   {
90579     try {
90580       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
90581     } catch (std::out_of_range& e) {
90582       {
90583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90584       };
90585     } catch (std::exception& e) {
90586       {
90587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90588       };
90589     } catch (Dali::DaliException e) {
90590       {
90591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90592       };
90593     } catch (...) {
90594       {
90595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90596       };
90597     }
90598   }
90599
90600   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90601
90602   //argout typemap for const std::string&
90603
90604   return jresult;
90605 }
90606
90607
90608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
90609   void * jresult ;
90610   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90611
90612   {
90613     try {
90614       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
90615     } catch (std::out_of_range& e) {
90616       {
90617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90618       };
90619     } catch (std::exception& e) {
90620       {
90621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90622       };
90623     } catch (Dali::DaliException e) {
90624       {
90625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90626       };
90627     } catch (...) {
90628       {
90629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90630       };
90631     }
90632   }
90633
90634   jresult = (void *)result;
90635   return jresult;
90636 }
90637
90638
90639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
90640   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90641
90642   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90643   {
90644     try {
90645       delete arg1;
90646     } catch (std::out_of_range& e) {
90647       {
90648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90649       };
90650     } catch (std::exception& e) {
90651       {
90652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90653       };
90654     } catch (Dali::DaliException e) {
90655       {
90656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90657       };
90658     } catch (...) {
90659       {
90660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90661       };
90662     }
90663   }
90664
90665 }
90666
90667
90668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
90669   void * jresult ;
90670   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
90671   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90672
90673   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90674   if (!arg1) {
90675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90676     return 0;
90677   }
90678   {
90679     try {
90680       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
90681     } catch (std::out_of_range& e) {
90682       {
90683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90684       };
90685     } catch (std::exception& e) {
90686       {
90687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90688       };
90689     } catch (Dali::DaliException e) {
90690       {
90691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90692       };
90693     } catch (...) {
90694       {
90695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90696       };
90697     }
90698   }
90699
90700   jresult = (void *)result;
90701   return jresult;
90702 }
90703
90704
90705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
90706   void * jresult ;
90707   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90708   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
90709   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90710
90711   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90712   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
90713   if (!arg2) {
90714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90715     return 0;
90716   }
90717   {
90718     try {
90719       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
90720     } catch (std::out_of_range& e) {
90721       {
90722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90723       };
90724     } catch (std::exception& e) {
90725       {
90726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90727       };
90728     } catch (Dali::DaliException e) {
90729       {
90730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90731       };
90732     } catch (...) {
90733       {
90734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90735       };
90736     }
90737   }
90738
90739   jresult = (void *)result;
90740   return jresult;
90741 }
90742
90743
90744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
90745   void * jresult ;
90746   Dali::Toolkit::AsyncImageLoader result;
90747
90748   {
90749     try {
90750       result = Dali::Toolkit::AsyncImageLoader::New();
90751     } catch (std::out_of_range& e) {
90752       {
90753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90754       };
90755     } catch (std::exception& e) {
90756       {
90757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90758       };
90759     } catch (Dali::DaliException e) {
90760       {
90761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90762       };
90763     } catch (...) {
90764       {
90765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90766       };
90767     }
90768   }
90769
90770   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90771   return jresult;
90772 }
90773
90774
90775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
90776   void * jresult ;
90777   Dali::BaseHandle arg1 ;
90778   Dali::BaseHandle *argp1 ;
90779   Dali::Toolkit::AsyncImageLoader result;
90780
90781   argp1 = (Dali::BaseHandle *)jarg1;
90782   if (!argp1) {
90783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90784     return 0;
90785   }
90786   arg1 = *argp1;
90787   {
90788     try {
90789       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
90790     } catch (std::out_of_range& e) {
90791       {
90792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90793       };
90794     } catch (std::exception& e) {
90795       {
90796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90797       };
90798     } catch (Dali::DaliException e) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90801       };
90802     } catch (...) {
90803       {
90804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90805       };
90806     }
90807   }
90808
90809   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90810   return jresult;
90811 }
90812
90813
90814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
90815   unsigned int jresult ;
90816   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90817   std::string *arg2 = 0 ;
90818   uint32_t result;
90819
90820   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90821   if (!jarg2) {
90822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90823     return 0;
90824   }
90825   std::string arg2_str(jarg2);
90826   arg2 = &arg2_str;
90827   {
90828     try {
90829       result = (arg1)->Load((std::string const &)*arg2);
90830     } catch (std::out_of_range& e) {
90831       {
90832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90833       };
90834     } catch (std::exception& e) {
90835       {
90836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90837       };
90838     } catch (Dali::DaliException e) {
90839       {
90840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90841       };
90842     } catch (...) {
90843       {
90844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90845       };
90846     }
90847   }
90848
90849   jresult = result;
90850
90851   //argout typemap for const std::string&
90852
90853   return jresult;
90854 }
90855
90856
90857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
90858   unsigned int jresult ;
90859   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90860   std::string *arg2 = 0 ;
90861   Dali::ImageDimensions arg3 ;
90862   Dali::ImageDimensions *argp3 ;
90863   uint32_t result;
90864
90865   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90866   if (!jarg2) {
90867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90868     return 0;
90869   }
90870   std::string arg2_str(jarg2);
90871   arg2 = &arg2_str;
90872   argp3 = (Dali::ImageDimensions *)jarg3;
90873   if (!argp3) {
90874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90875     return 0;
90876   }
90877   arg3 = *argp3;
90878   {
90879     try {
90880       result = (arg1)->Load((std::string const &)*arg2,arg3);
90881     } catch (std::out_of_range& e) {
90882       {
90883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90884       };
90885     } catch (std::exception& e) {
90886       {
90887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90888       };
90889     } catch (Dali::DaliException e) {
90890       {
90891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90892       };
90893     } catch (...) {
90894       {
90895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90896       };
90897     }
90898   }
90899
90900   jresult = result;
90901
90902   //argout typemap for const std::string&
90903
90904   return jresult;
90905 }
90906
90907
90908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
90909   unsigned int jresult ;
90910   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90911   std::string *arg2 = 0 ;
90912   Dali::ImageDimensions arg3 ;
90913   Dali::FittingMode::Type arg4 ;
90914   Dali::SamplingMode::Type arg5 ;
90915   bool arg6 ;
90916   Dali::ImageDimensions *argp3 ;
90917   uint32_t result;
90918
90919   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90920   if (!jarg2) {
90921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90922     return 0;
90923   }
90924   std::string arg2_str(jarg2);
90925   arg2 = &arg2_str;
90926   argp3 = (Dali::ImageDimensions *)jarg3;
90927   if (!argp3) {
90928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90929     return 0;
90930   }
90931   arg3 = *argp3;
90932   arg4 = (Dali::FittingMode::Type)jarg4;
90933   arg5 = (Dali::SamplingMode::Type)jarg5;
90934   arg6 = jarg6 ? true : false;
90935   {
90936     try {
90937       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
90938     } catch (std::out_of_range& e) {
90939       {
90940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90941       };
90942     } catch (std::exception& e) {
90943       {
90944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90945       };
90946     } catch (Dali::DaliException e) {
90947       {
90948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90949       };
90950     } catch (...) {
90951       {
90952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90953       };
90954     }
90955   }
90956
90957   jresult = result;
90958
90959   //argout typemap for const std::string&
90960
90961   return jresult;
90962 }
90963
90964
90965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
90966   unsigned int jresult ;
90967   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90968   uint32_t arg2 ;
90969   bool result;
90970
90971   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90972   arg2 = (uint32_t)jarg2;
90973   {
90974     try {
90975       result = (bool)(arg1)->Cancel(arg2);
90976     } catch (std::out_of_range& e) {
90977       {
90978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90979       };
90980     } catch (std::exception& e) {
90981       {
90982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90983       };
90984     } catch (Dali::DaliException e) {
90985       {
90986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90987       };
90988     } catch (...) {
90989       {
90990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90991       };
90992     }
90993   }
90994
90995   jresult = result;
90996   return jresult;
90997 }
90998
90999
91000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91001   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91002
91003   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91004   {
91005     try {
91006       (arg1)->CancelAll();
91007     } catch (std::out_of_range& e) {
91008       {
91009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91010       };
91011     } catch (std::exception& e) {
91012       {
91013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91014       };
91015     } catch (Dali::DaliException e) {
91016       {
91017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91018       };
91019     } catch (...) {
91020       {
91021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91022       };
91023     }
91024   }
91025
91026 }
91027
91028
91029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
91030   void * jresult ;
91031   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91032   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
91033
91034   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91035   {
91036     try {
91037       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
91038     } catch (std::out_of_range& e) {
91039       {
91040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91041       };
91042     } catch (std::exception& e) {
91043       {
91044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91045       };
91046     } catch (Dali::DaliException e) {
91047       {
91048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91049       };
91050     } catch (...) {
91051       {
91052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91053       };
91054     }
91055   }
91056
91057   jresult = (void *)result;
91058   return jresult;
91059 }
91060
91061
91062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
91063   void * jresult ;
91064   std::string *arg1 = 0 ;
91065   Dali::PixelData result;
91066
91067   if (!jarg1) {
91068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91069     return 0;
91070   }
91071   std::string arg1_str(jarg1);
91072   arg1 = &arg1_str;
91073   {
91074     try {
91075       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
91076     } catch (std::out_of_range& e) {
91077       {
91078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91079       };
91080     } catch (std::exception& e) {
91081       {
91082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91083       };
91084     } catch (Dali::DaliException e) {
91085       {
91086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91087       };
91088     } catch (...) {
91089       {
91090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91091       };
91092     }
91093   }
91094
91095   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91096
91097   //argout typemap for const std::string&
91098
91099   return jresult;
91100 }
91101
91102
91103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
91104   void * jresult ;
91105   std::string *arg1 = 0 ;
91106   Dali::ImageDimensions arg2 ;
91107   Dali::ImageDimensions *argp2 ;
91108   Dali::PixelData result;
91109
91110   if (!jarg1) {
91111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91112     return 0;
91113   }
91114   std::string arg1_str(jarg1);
91115   arg1 = &arg1_str;
91116   argp2 = (Dali::ImageDimensions *)jarg2;
91117   if (!argp2) {
91118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91119     return 0;
91120   }
91121   arg2 = *argp2;
91122   {
91123     try {
91124       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
91125     } catch (std::out_of_range& e) {
91126       {
91127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91128       };
91129     } catch (std::exception& e) {
91130       {
91131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91132       };
91133     } catch (Dali::DaliException e) {
91134       {
91135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91136       };
91137     } catch (...) {
91138       {
91139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91140       };
91141     }
91142   }
91143
91144   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91145
91146   //argout typemap for const std::string&
91147
91148   return jresult;
91149 }
91150
91151
91152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91153   void * jresult ;
91154   std::string *arg1 = 0 ;
91155   Dali::ImageDimensions arg2 ;
91156   Dali::FittingMode::Type arg3 ;
91157   Dali::SamplingMode::Type arg4 ;
91158   bool arg5 ;
91159   Dali::ImageDimensions *argp2 ;
91160   Dali::PixelData result;
91161
91162   if (!jarg1) {
91163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91164     return 0;
91165   }
91166   std::string arg1_str(jarg1);
91167   arg1 = &arg1_str;
91168   argp2 = (Dali::ImageDimensions *)jarg2;
91169   if (!argp2) {
91170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91171     return 0;
91172   }
91173   arg2 = *argp2;
91174   arg3 = (Dali::FittingMode::Type)jarg3;
91175   arg4 = (Dali::SamplingMode::Type)jarg4;
91176   arg5 = jarg5 ? true : false;
91177   {
91178     try {
91179       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91180     } catch (std::out_of_range& e) {
91181       {
91182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91183       };
91184     } catch (std::exception& e) {
91185       {
91186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91187       };
91188     } catch (Dali::DaliException e) {
91189       {
91190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91191       };
91192     } catch (...) {
91193       {
91194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91195       };
91196     }
91197   }
91198
91199   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91200
91201   //argout typemap for const std::string&
91202
91203   return jresult;
91204 }
91205
91206
91207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91208   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91209
91210   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91211   {
91212     try {
91213       delete arg1;
91214     } catch (std::out_of_range& e) {
91215       {
91216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91217       };
91218     } catch (std::exception& e) {
91219       {
91220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91221       };
91222     } catch (Dali::DaliException e) {
91223       {
91224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91225       };
91226     } catch (...) {
91227       {
91228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91229       };
91230     }
91231   }
91232
91233 }
91234
91235
91236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
91237   void * jresult ;
91238   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91239   Dali::Actor arg2 ;
91240   Dali::Actor arg3 ;
91241   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
91242   Dali::Actor *argp2 ;
91243   Dali::Actor *argp3 ;
91244   Dali::Actor result;
91245
91246   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91247   argp2 = (Dali::Actor *)jarg2;
91248   if (!argp2) {
91249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91250     return 0;
91251   }
91252   arg2 = *argp2;
91253   argp3 = (Dali::Actor *)jarg3;
91254   if (!argp3) {
91255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91256     return 0;
91257   }
91258   arg3 = *argp3;
91259   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
91260   {
91261     try {
91262       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
91263     } catch (std::out_of_range& e) {
91264       {
91265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91266       };
91267     } catch (std::exception& e) {
91268       {
91269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91270       };
91271     } catch (Dali::DaliException e) {
91272       {
91273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91274       };
91275     } catch (...) {
91276       {
91277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91278       };
91279     }
91280   }
91281
91282   jresult = new Dali::Actor((const Dali::Actor &)result);
91283   return jresult;
91284 }
91285
91286
91287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
91288   void * jresult ;
91289   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
91290
91291   {
91292     try {
91293       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
91294     } catch (std::out_of_range& e) {
91295       {
91296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91297       };
91298     } catch (std::exception& e) {
91299       {
91300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91301       };
91302     } catch (Dali::DaliException e) {
91303       {
91304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91305       };
91306     } catch (...) {
91307       {
91308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91309       };
91310     }
91311   }
91312
91313   jresult = (void *)result;
91314   return jresult;
91315 }
91316
91317
91318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
91319   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
91320   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
91321   if (director) {
91322     director->swig_connect_director(callback0);
91323   }
91324 }
91325
91326
91327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
91328   KeyboardFocusManager arg1 ;
91329   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
91330   KeyboardFocusManager *argp1 ;
91331
91332   argp1 = (KeyboardFocusManager *)jarg1;
91333   if (!argp1) {
91334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
91335     return ;
91336   }
91337   arg1 = *argp1;
91338   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
91339   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
91340   {
91341     try {
91342       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
91343     } catch (std::out_of_range& e) {
91344       {
91345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91346       };
91347     } catch (std::exception& e) {
91348       {
91349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91350       };
91351     } catch (Dali::DaliException e) {
91352       {
91353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91354       };
91355     } catch (...) {
91356       {
91357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91358       };
91359     }
91360   }
91361
91362 }
91363
91364
91365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
91366   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91367
91368   arg1 = (std::vector< unsigned int > *)jarg1;
91369   {
91370     try {
91371       (arg1)->clear();
91372     } catch (std::out_of_range& e) {
91373       {
91374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91375       };
91376     } catch (std::exception& e) {
91377       {
91378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91379       };
91380     } catch (Dali::DaliException e) {
91381       {
91382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91383       };
91384     } catch (...) {
91385       {
91386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91387       };
91388     }
91389   }
91390
91391 }
91392
91393
91394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
91395   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91396   unsigned int *arg2 = 0 ;
91397   unsigned int temp2 ;
91398
91399   arg1 = (std::vector< unsigned int > *)jarg1;
91400   temp2 = (unsigned int)jarg2;
91401   arg2 = &temp2;
91402   {
91403     try {
91404       (arg1)->push_back((unsigned int const &)*arg2);
91405     } catch (std::out_of_range& e) {
91406       {
91407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91408       };
91409     } catch (std::exception& e) {
91410       {
91411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91412       };
91413     } catch (Dali::DaliException e) {
91414       {
91415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91416       };
91417     } catch (...) {
91418       {
91419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91420       };
91421     }
91422   }
91423
91424 }
91425
91426
91427 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
91428   unsigned long jresult ;
91429   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91430   std::vector< unsigned int >::size_type result;
91431
91432   arg1 = (std::vector< unsigned int > *)jarg1;
91433   {
91434     try {
91435       result = ((std::vector< unsigned int > const *)arg1)->size();
91436     } catch (std::out_of_range& e) {
91437       {
91438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91439       };
91440     } catch (std::exception& e) {
91441       {
91442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91443       };
91444     } catch (Dali::DaliException e) {
91445       {
91446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91447       };
91448     } catch (...) {
91449       {
91450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91451       };
91452     }
91453   }
91454
91455   jresult = (unsigned long)result;
91456   return jresult;
91457 }
91458
91459
91460 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
91461   unsigned long jresult ;
91462   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91463   std::vector< unsigned int >::size_type result;
91464
91465   arg1 = (std::vector< unsigned int > *)jarg1;
91466   {
91467     try {
91468       result = ((std::vector< unsigned int > const *)arg1)->capacity();
91469     } catch (std::out_of_range& e) {
91470       {
91471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91472       };
91473     } catch (std::exception& e) {
91474       {
91475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91476       };
91477     } catch (Dali::DaliException e) {
91478       {
91479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91480       };
91481     } catch (...) {
91482       {
91483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91484       };
91485     }
91486   }
91487
91488   jresult = (unsigned long)result;
91489   return jresult;
91490 }
91491
91492
91493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
91494   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91495   std::vector< unsigned int >::size_type arg2 ;
91496
91497   arg1 = (std::vector< unsigned int > *)jarg1;
91498   arg2 = (std::vector< unsigned int >::size_type)jarg2;
91499   {
91500     try {
91501       (arg1)->reserve(arg2);
91502     } catch (std::out_of_range& e) {
91503       {
91504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91505       };
91506     } catch (std::exception& e) {
91507       {
91508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91509       };
91510     } catch (Dali::DaliException e) {
91511       {
91512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91513       };
91514     } catch (...) {
91515       {
91516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91517       };
91518     }
91519   }
91520
91521 }
91522
91523
91524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
91525   void * jresult ;
91526   std::vector< unsigned int > *result = 0 ;
91527
91528   {
91529     try {
91530       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
91531     } catch (std::out_of_range& e) {
91532       {
91533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91534       };
91535     } catch (std::exception& e) {
91536       {
91537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91538       };
91539     } catch (Dali::DaliException e) {
91540       {
91541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91542       };
91543     } catch (...) {
91544       {
91545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91546       };
91547     }
91548   }
91549
91550   jresult = (void *)result;
91551   return jresult;
91552 }
91553
91554
91555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
91556   void * jresult ;
91557   std::vector< unsigned int > *arg1 = 0 ;
91558   std::vector< unsigned int > *result = 0 ;
91559
91560   arg1 = (std::vector< unsigned int > *)jarg1;
91561   if (!arg1) {
91562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91563     return 0;
91564   }
91565   {
91566     try {
91567       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
91568     } catch (std::out_of_range& e) {
91569       {
91570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91571       };
91572     } catch (std::exception& e) {
91573       {
91574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91575       };
91576     } catch (Dali::DaliException e) {
91577       {
91578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91579       };
91580     } catch (...) {
91581       {
91582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91583       };
91584     }
91585   }
91586
91587   jresult = (void *)result;
91588   return jresult;
91589 }
91590
91591
91592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
91593   void * jresult ;
91594   int arg1 ;
91595   std::vector< unsigned int > *result = 0 ;
91596
91597   arg1 = (int)jarg1;
91598   {
91599     try {
91600       try {
91601         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
91602       }
91603       catch(std::out_of_range &_e) {
91604         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91605         return 0;
91606       }
91607
91608     } catch (std::out_of_range& e) {
91609       {
91610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91611       };
91612     } catch (std::exception& e) {
91613       {
91614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91615       };
91616     } catch (Dali::DaliException e) {
91617       {
91618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91619       };
91620     } catch (...) {
91621       {
91622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91623       };
91624     }
91625   }
91626
91627   jresult = (void *)result;
91628   return jresult;
91629 }
91630
91631
91632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
91633   unsigned int jresult ;
91634   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91635   int arg2 ;
91636   unsigned int result;
91637
91638   arg1 = (std::vector< unsigned int > *)jarg1;
91639   arg2 = (int)jarg2;
91640   {
91641     try {
91642       try {
91643         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
91644       }
91645       catch(std::out_of_range &_e) {
91646         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91647         return 0;
91648       }
91649
91650     } catch (std::out_of_range& e) {
91651       {
91652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91653       };
91654     } catch (std::exception& e) {
91655       {
91656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91657       };
91658     } catch (Dali::DaliException e) {
91659       {
91660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91661       };
91662     } catch (...) {
91663       {
91664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91665       };
91666     }
91667   }
91668
91669   jresult = result;
91670   return jresult;
91671 }
91672
91673
91674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
91675   unsigned int jresult ;
91676   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91677   int arg2 ;
91678   unsigned int *result = 0 ;
91679
91680   arg1 = (std::vector< unsigned int > *)jarg1;
91681   arg2 = (int)jarg2;
91682   {
91683     try {
91684       try {
91685         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
91686       }
91687       catch(std::out_of_range &_e) {
91688         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91689         return 0;
91690       }
91691
91692     } catch (std::out_of_range& e) {
91693       {
91694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91695       };
91696     } catch (std::exception& e) {
91697       {
91698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91699       };
91700     } catch (Dali::DaliException e) {
91701       {
91702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91703       };
91704     } catch (...) {
91705       {
91706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91707       };
91708     }
91709   }
91710
91711   jresult = *result;
91712   return jresult;
91713 }
91714
91715
91716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
91717   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91718   int arg2 ;
91719   unsigned int *arg3 = 0 ;
91720   unsigned int temp3 ;
91721
91722   arg1 = (std::vector< unsigned int > *)jarg1;
91723   arg2 = (int)jarg2;
91724   temp3 = (unsigned int)jarg3;
91725   arg3 = &temp3;
91726   {
91727     try {
91728       try {
91729         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
91730       }
91731       catch(std::out_of_range &_e) {
91732         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91733         return ;
91734       }
91735
91736     } catch (std::out_of_range& e) {
91737       {
91738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91739       };
91740     } catch (std::exception& e) {
91741       {
91742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91743       };
91744     } catch (Dali::DaliException e) {
91745       {
91746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91747       };
91748     } catch (...) {
91749       {
91750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91751       };
91752     }
91753   }
91754
91755 }
91756
91757
91758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
91759   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91760   std::vector< unsigned int > *arg2 = 0 ;
91761
91762   arg1 = (std::vector< unsigned int > *)jarg1;
91763   arg2 = (std::vector< unsigned int > *)jarg2;
91764   if (!arg2) {
91765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91766     return ;
91767   }
91768   {
91769     try {
91770       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
91771     } catch (std::out_of_range& e) {
91772       {
91773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91774       };
91775     } catch (std::exception& e) {
91776       {
91777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91778       };
91779     } catch (Dali::DaliException e) {
91780       {
91781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91782       };
91783     } catch (...) {
91784       {
91785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91786       };
91787     }
91788   }
91789
91790 }
91791
91792
91793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91794   void * jresult ;
91795   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91796   int arg2 ;
91797   int arg3 ;
91798   std::vector< unsigned int > *result = 0 ;
91799
91800   arg1 = (std::vector< unsigned int > *)jarg1;
91801   arg2 = (int)jarg2;
91802   arg3 = (int)jarg3;
91803   {
91804     try {
91805       try {
91806         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
91807       }
91808       catch(std::out_of_range &_e) {
91809         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91810         return 0;
91811       }
91812       catch(std::invalid_argument &_e) {
91813         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91814         return 0;
91815       }
91816
91817     } catch (std::out_of_range& e) {
91818       {
91819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91820       };
91821     } catch (std::exception& e) {
91822       {
91823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91824       };
91825     } catch (Dali::DaliException e) {
91826       {
91827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91828       };
91829     } catch (...) {
91830       {
91831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91832       };
91833     }
91834   }
91835
91836   jresult = (void *)result;
91837   return jresult;
91838 }
91839
91840
91841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
91842   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91843   int arg2 ;
91844   unsigned int *arg3 = 0 ;
91845   unsigned int temp3 ;
91846
91847   arg1 = (std::vector< unsigned int > *)jarg1;
91848   arg2 = (int)jarg2;
91849   temp3 = (unsigned int)jarg3;
91850   arg3 = &temp3;
91851   {
91852     try {
91853       try {
91854         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
91855       }
91856       catch(std::out_of_range &_e) {
91857         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91858         return ;
91859       }
91860
91861     } catch (std::out_of_range& e) {
91862       {
91863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91864       };
91865     } catch (std::exception& e) {
91866       {
91867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91868       };
91869     } catch (Dali::DaliException e) {
91870       {
91871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91872       };
91873     } catch (...) {
91874       {
91875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91876       };
91877     }
91878   }
91879
91880 }
91881
91882
91883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91884   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91885   int arg2 ;
91886   std::vector< unsigned int > *arg3 = 0 ;
91887
91888   arg1 = (std::vector< unsigned int > *)jarg1;
91889   arg2 = (int)jarg2;
91890   arg3 = (std::vector< unsigned int > *)jarg3;
91891   if (!arg3) {
91892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91893     return ;
91894   }
91895   {
91896     try {
91897       try {
91898         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91899       }
91900       catch(std::out_of_range &_e) {
91901         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91902         return ;
91903       }
91904
91905     } catch (std::out_of_range& e) {
91906       {
91907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91908       };
91909     } catch (std::exception& e) {
91910       {
91911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91912       };
91913     } catch (Dali::DaliException e) {
91914       {
91915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91916       };
91917     } catch (...) {
91918       {
91919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91920       };
91921     }
91922   }
91923
91924 }
91925
91926
91927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
91928   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91929   int arg2 ;
91930
91931   arg1 = (std::vector< unsigned int > *)jarg1;
91932   arg2 = (int)jarg2;
91933   {
91934     try {
91935       try {
91936         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
91937       }
91938       catch(std::out_of_range &_e) {
91939         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91940         return ;
91941       }
91942
91943     } catch (std::out_of_range& e) {
91944       {
91945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91946       };
91947     } catch (std::exception& e) {
91948       {
91949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91950       };
91951     } catch (Dali::DaliException e) {
91952       {
91953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91954       };
91955     } catch (...) {
91956       {
91957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91958       };
91959     }
91960   }
91961
91962 }
91963
91964
91965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
91966   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91967   int arg2 ;
91968   int arg3 ;
91969
91970   arg1 = (std::vector< unsigned int > *)jarg1;
91971   arg2 = (int)jarg2;
91972   arg3 = (int)jarg3;
91973   {
91974     try {
91975       try {
91976         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
91977       }
91978       catch(std::out_of_range &_e) {
91979         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91980         return ;
91981       }
91982       catch(std::invalid_argument &_e) {
91983         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91984         return ;
91985       }
91986
91987     } catch (std::out_of_range& e) {
91988       {
91989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91990       };
91991     } catch (std::exception& e) {
91992       {
91993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91994       };
91995     } catch (Dali::DaliException e) {
91996       {
91997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91998       };
91999     } catch (...) {
92000       {
92001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92002       };
92003     }
92004   }
92005
92006 }
92007
92008
92009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
92010   void * jresult ;
92011   unsigned int *arg1 = 0 ;
92012   int arg2 ;
92013   unsigned int temp1 ;
92014   std::vector< unsigned int > *result = 0 ;
92015
92016   temp1 = (unsigned int)jarg1;
92017   arg1 = &temp1;
92018   arg2 = (int)jarg2;
92019   {
92020     try {
92021       try {
92022         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
92023       }
92024       catch(std::out_of_range &_e) {
92025         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92026         return 0;
92027       }
92028
92029     } catch (std::out_of_range& e) {
92030       {
92031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92032       };
92033     } catch (std::exception& e) {
92034       {
92035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92036       };
92037     } catch (Dali::DaliException e) {
92038       {
92039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92040       };
92041     } catch (...) {
92042       {
92043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92044       };
92045     }
92046   }
92047
92048   jresult = (void *)result;
92049   return jresult;
92050 }
92051
92052
92053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
92054   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92055
92056   arg1 = (std::vector< unsigned int > *)jarg1;
92057   {
92058     try {
92059       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
92060     } catch (std::out_of_range& e) {
92061       {
92062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92063       };
92064     } catch (std::exception& e) {
92065       {
92066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92067       };
92068     } catch (Dali::DaliException e) {
92069       {
92070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92071       };
92072     } catch (...) {
92073       {
92074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92075       };
92076     }
92077   }
92078
92079 }
92080
92081
92082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92083   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92084   int arg2 ;
92085   int arg3 ;
92086
92087   arg1 = (std::vector< unsigned int > *)jarg1;
92088   arg2 = (int)jarg2;
92089   arg3 = (int)jarg3;
92090   {
92091     try {
92092       try {
92093         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92094       }
92095       catch(std::out_of_range &_e) {
92096         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92097         return ;
92098       }
92099       catch(std::invalid_argument &_e) {
92100         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92101         return ;
92102       }
92103
92104     } catch (std::out_of_range& e) {
92105       {
92106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92107       };
92108     } catch (std::exception& e) {
92109       {
92110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92111       };
92112     } catch (Dali::DaliException e) {
92113       {
92114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92115       };
92116     } catch (...) {
92117       {
92118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92119       };
92120     }
92121   }
92122
92123 }
92124
92125
92126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92127   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92128   int arg2 ;
92129   std::vector< unsigned int > *arg3 = 0 ;
92130
92131   arg1 = (std::vector< unsigned int > *)jarg1;
92132   arg2 = (int)jarg2;
92133   arg3 = (std::vector< unsigned int > *)jarg3;
92134   if (!arg3) {
92135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92136     return ;
92137   }
92138   {
92139     try {
92140       try {
92141         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92142       }
92143       catch(std::out_of_range &_e) {
92144         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92145         return ;
92146       }
92147
92148     } catch (std::out_of_range& e) {
92149       {
92150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92151       };
92152     } catch (std::exception& e) {
92153       {
92154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92155       };
92156     } catch (Dali::DaliException e) {
92157       {
92158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92159       };
92160     } catch (...) {
92161       {
92162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92163       };
92164     }
92165   }
92166
92167 }
92168
92169
92170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92171   unsigned int jresult ;
92172   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92173   unsigned int *arg2 = 0 ;
92174   unsigned int temp2 ;
92175   bool result;
92176
92177   arg1 = (std::vector< unsigned int > *)jarg1;
92178   temp2 = (unsigned int)jarg2;
92179   arg2 = &temp2;
92180   {
92181     try {
92182       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92183     } catch (std::out_of_range& e) {
92184       {
92185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92186       };
92187     } catch (std::exception& e) {
92188       {
92189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92190       };
92191     } catch (Dali::DaliException e) {
92192       {
92193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92194       };
92195     } catch (...) {
92196       {
92197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92198       };
92199     }
92200   }
92201
92202   jresult = result;
92203   return jresult;
92204 }
92205
92206
92207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92208   int jresult ;
92209   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92210   unsigned int *arg2 = 0 ;
92211   unsigned int temp2 ;
92212   int result;
92213
92214   arg1 = (std::vector< unsigned int > *)jarg1;
92215   temp2 = (unsigned int)jarg2;
92216   arg2 = &temp2;
92217   {
92218     try {
92219       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92220     } catch (std::out_of_range& e) {
92221       {
92222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92223       };
92224     } catch (std::exception& e) {
92225       {
92226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92227       };
92228     } catch (Dali::DaliException e) {
92229       {
92230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92231       };
92232     } catch (...) {
92233       {
92234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92235       };
92236     }
92237   }
92238
92239   jresult = result;
92240   return jresult;
92241 }
92242
92243
92244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
92245   int jresult ;
92246   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92247   unsigned int *arg2 = 0 ;
92248   unsigned int temp2 ;
92249   int result;
92250
92251   arg1 = (std::vector< unsigned int > *)jarg1;
92252   temp2 = (unsigned int)jarg2;
92253   arg2 = &temp2;
92254   {
92255     try {
92256       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
92257     } catch (std::out_of_range& e) {
92258       {
92259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92260       };
92261     } catch (std::exception& e) {
92262       {
92263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92264       };
92265     } catch (Dali::DaliException e) {
92266       {
92267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92268       };
92269     } catch (...) {
92270       {
92271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92272       };
92273     }
92274   }
92275
92276   jresult = result;
92277   return jresult;
92278 }
92279
92280
92281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
92282   unsigned int jresult ;
92283   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92284   unsigned int *arg2 = 0 ;
92285   unsigned int temp2 ;
92286   bool result;
92287
92288   arg1 = (std::vector< unsigned int > *)jarg1;
92289   temp2 = (unsigned int)jarg2;
92290   arg2 = &temp2;
92291   {
92292     try {
92293       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
92294     } catch (std::out_of_range& e) {
92295       {
92296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92297       };
92298     } catch (std::exception& e) {
92299       {
92300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92301       };
92302     } catch (Dali::DaliException e) {
92303       {
92304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92305       };
92306     } catch (...) {
92307       {
92308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92309       };
92310     }
92311   }
92312
92313   jresult = result;
92314   return jresult;
92315 }
92316
92317
92318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
92319   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92320
92321   arg1 = (std::vector< unsigned int > *)jarg1;
92322   {
92323     try {
92324       delete arg1;
92325     } catch (std::out_of_range& e) {
92326       {
92327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92328       };
92329     } catch (std::exception& e) {
92330       {
92331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92332       };
92333     } catch (Dali::DaliException e) {
92334       {
92335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92336       };
92337     } catch (...) {
92338       {
92339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92340       };
92341     }
92342   }
92343
92344 }
92345
92346
92347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
92348   void * jresult ;
92349   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92350
92351   {
92352     try {
92353       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
92354     } catch (std::out_of_range& e) {
92355       {
92356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92357       };
92358     } catch (std::exception& e) {
92359       {
92360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92361       };
92362     } catch (Dali::DaliException e) {
92363       {
92364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92365       };
92366     } catch (...) {
92367       {
92368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92369       };
92370     }
92371   }
92372
92373   jresult = (void *)result;
92374   return jresult;
92375 }
92376
92377
92378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
92379   void * jresult ;
92380   unsigned int arg1 ;
92381   Dali::Actor arg2 ;
92382   Dali::Actor *argp2 ;
92383   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92384
92385   arg1 = (unsigned int)jarg1;
92386   argp2 = (Dali::Actor *)jarg2;
92387   if (!argp2) {
92388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92389     return 0;
92390   }
92391   arg2 = *argp2;
92392   {
92393     try {
92394       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
92395     } catch (std::out_of_range& e) {
92396       {
92397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92398       };
92399     } catch (std::exception& e) {
92400       {
92401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92402       };
92403     } catch (Dali::DaliException e) {
92404       {
92405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92406       };
92407     } catch (...) {
92408       {
92409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92410       };
92411     }
92412   }
92413
92414   jresult = (void *)result;
92415   return jresult;
92416 }
92417
92418
92419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
92420   void * jresult ;
92421   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
92422   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92423
92424   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92425   if (!arg1) {
92426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92427     return 0;
92428   }
92429   {
92430     try {
92431       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
92432     } catch (std::out_of_range& e) {
92433       {
92434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92435       };
92436     } catch (std::exception& e) {
92437       {
92438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92439       };
92440     } catch (Dali::DaliException e) {
92441       {
92442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92443       };
92444     } catch (...) {
92445       {
92446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92447       };
92448     }
92449   }
92450
92451   jresult = (void *)result;
92452   return jresult;
92453 }
92454
92455
92456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
92457   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92458   unsigned int arg2 ;
92459
92460   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92461   arg2 = (unsigned int)jarg2;
92462   if (arg1) (arg1)->first = arg2;
92463 }
92464
92465
92466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
92467   unsigned int jresult ;
92468   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92469   unsigned int result;
92470
92471   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92472   result = (unsigned int) ((arg1)->first);
92473   jresult = result;
92474   return jresult;
92475 }
92476
92477
92478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
92479   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92480   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
92481
92482   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92483   arg2 = (Dali::Actor *)jarg2;
92484   if (arg1) (arg1)->second = *arg2;
92485 }
92486
92487
92488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
92489   void * jresult ;
92490   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92491   Dali::Actor *result = 0 ;
92492
92493   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92494   result = (Dali::Actor *)& ((arg1)->second);
92495   jresult = (void *)result;
92496   return jresult;
92497 }
92498
92499
92500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
92501   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92502
92503   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92504   {
92505     try {
92506       delete arg1;
92507     } catch (std::out_of_range& e) {
92508       {
92509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92510       };
92511     } catch (std::exception& e) {
92512       {
92513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92514       };
92515     } catch (Dali::DaliException e) {
92516       {
92517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92518       };
92519     } catch (...) {
92520       {
92521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92522       };
92523     }
92524   }
92525
92526 }
92527
92528
92529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
92530   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92531
92532   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92533   {
92534     try {
92535       (arg1)->clear();
92536     } catch (std::out_of_range& e) {
92537       {
92538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92539       };
92540     } catch (std::exception& e) {
92541       {
92542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92543       };
92544     } catch (Dali::DaliException e) {
92545       {
92546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92547       };
92548     } catch (...) {
92549       {
92550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92551       };
92552     }
92553   }
92554
92555 }
92556
92557
92558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
92559   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92560   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
92561
92562   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92563   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
92564   if (!arg2) {
92565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92566     return ;
92567   }
92568   {
92569     try {
92570       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
92571     } catch (std::out_of_range& e) {
92572       {
92573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92574       };
92575     } catch (std::exception& e) {
92576       {
92577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92578       };
92579     } catch (Dali::DaliException e) {
92580       {
92581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92582       };
92583     } catch (...) {
92584       {
92585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92586       };
92587     }
92588   }
92589
92590 }
92591
92592
92593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
92594   unsigned long jresult ;
92595   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92596   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92597
92598   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92599   {
92600     try {
92601       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
92602     } catch (std::out_of_range& e) {
92603       {
92604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92605       };
92606     } catch (std::exception& e) {
92607       {
92608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92609       };
92610     } catch (Dali::DaliException e) {
92611       {
92612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92613       };
92614     } catch (...) {
92615       {
92616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92617       };
92618     }
92619   }
92620
92621   jresult = (unsigned long)result;
92622   return jresult;
92623 }
92624
92625
92626 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
92627   unsigned long jresult ;
92628   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92629   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92630
92631   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92632   {
92633     try {
92634       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
92635     } catch (std::out_of_range& e) {
92636       {
92637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92638       };
92639     } catch (std::exception& e) {
92640       {
92641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92642       };
92643     } catch (Dali::DaliException e) {
92644       {
92645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92646       };
92647     } catch (...) {
92648       {
92649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92650       };
92651     }
92652   }
92653
92654   jresult = (unsigned long)result;
92655   return jresult;
92656 }
92657
92658
92659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
92660   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92661   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
92662
92663   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92664   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
92665   {
92666     try {
92667       (arg1)->reserve(arg2);
92668     } catch (std::out_of_range& e) {
92669       {
92670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92671       };
92672     } catch (std::exception& e) {
92673       {
92674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92675       };
92676     } catch (Dali::DaliException e) {
92677       {
92678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92679       };
92680     } catch (...) {
92681       {
92682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92683       };
92684     }
92685   }
92686
92687 }
92688
92689
92690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
92691   void * jresult ;
92692   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92693
92694   {
92695     try {
92696       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
92697     } catch (std::out_of_range& e) {
92698       {
92699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92700       };
92701     } catch (std::exception& e) {
92702       {
92703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92704       };
92705     } catch (Dali::DaliException e) {
92706       {
92707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92708       };
92709     } catch (...) {
92710       {
92711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92712       };
92713     }
92714   }
92715
92716   jresult = (void *)result;
92717   return jresult;
92718 }
92719
92720
92721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
92722   void * jresult ;
92723   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
92724   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92725
92726   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92727   if (!arg1) {
92728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92729     return 0;
92730   }
92731   {
92732     try {
92733       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);
92734     } catch (std::out_of_range& e) {
92735       {
92736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92737       };
92738     } catch (std::exception& e) {
92739       {
92740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92741       };
92742     } catch (Dali::DaliException e) {
92743       {
92744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92745       };
92746     } catch (...) {
92747       {
92748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92749       };
92750     }
92751   }
92752
92753   jresult = (void *)result;
92754   return jresult;
92755 }
92756
92757
92758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
92759   void * jresult ;
92760   int arg1 ;
92761   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92762
92763   arg1 = (int)jarg1;
92764   {
92765     try {
92766       try {
92767         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);
92768       }
92769       catch(std::out_of_range &_e) {
92770         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92771         return 0;
92772       }
92773
92774     } catch (std::out_of_range& e) {
92775       {
92776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92777       };
92778     } catch (std::exception& e) {
92779       {
92780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92781       };
92782     } catch (Dali::DaliException e) {
92783       {
92784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92785       };
92786     } catch (...) {
92787       {
92788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92789       };
92790     }
92791   }
92792
92793   jresult = (void *)result;
92794   return jresult;
92795 }
92796
92797
92798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
92799   void * jresult ;
92800   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92801   int arg2 ;
92802   std::pair< unsigned int,Dali::Actor > result;
92803
92804   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92805   arg2 = (int)jarg2;
92806   {
92807     try {
92808       try {
92809         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
92810       }
92811       catch(std::out_of_range &_e) {
92812         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92813         return 0;
92814       }
92815
92816     } catch (std::out_of_range& e) {
92817       {
92818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92819       };
92820     } catch (std::exception& e) {
92821       {
92822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92823       };
92824     } catch (Dali::DaliException e) {
92825       {
92826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92827       };
92828     } catch (...) {
92829       {
92830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92831       };
92832     }
92833   }
92834
92835   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
92836   return jresult;
92837 }
92838
92839
92840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
92841   void * jresult ;
92842   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92843   int arg2 ;
92844   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92845
92846   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92847   arg2 = (int)jarg2;
92848   {
92849     try {
92850       try {
92851         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
92852       }
92853       catch(std::out_of_range &_e) {
92854         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92855         return 0;
92856       }
92857
92858     } catch (std::out_of_range& e) {
92859       {
92860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92861       };
92862     } catch (std::exception& e) {
92863       {
92864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92865       };
92866     } catch (Dali::DaliException e) {
92867       {
92868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92869       };
92870     } catch (...) {
92871       {
92872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92873       };
92874     }
92875   }
92876
92877   jresult = (void *)result;
92878   return jresult;
92879 }
92880
92881
92882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
92883   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92884   int arg2 ;
92885   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92886
92887   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92888   arg2 = (int)jarg2;
92889   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92890   if (!arg3) {
92891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92892     return ;
92893   }
92894   {
92895     try {
92896       try {
92897         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);
92898       }
92899       catch(std::out_of_range &_e) {
92900         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92901         return ;
92902       }
92903
92904     } catch (std::out_of_range& e) {
92905       {
92906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92907       };
92908     } catch (std::exception& e) {
92909       {
92910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92911       };
92912     } catch (Dali::DaliException e) {
92913       {
92914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92915       };
92916     } catch (...) {
92917       {
92918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92919       };
92920     }
92921   }
92922
92923 }
92924
92925
92926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
92927   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92928   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
92929
92930   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92931   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
92932   if (!arg2) {
92933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92934     return ;
92935   }
92936   {
92937     try {
92938       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);
92939     } catch (std::out_of_range& e) {
92940       {
92941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92942       };
92943     } catch (std::exception& e) {
92944       {
92945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92946       };
92947     } catch (Dali::DaliException e) {
92948       {
92949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92950       };
92951     } catch (...) {
92952       {
92953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92954       };
92955     }
92956   }
92957
92958 }
92959
92960
92961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92962   void * jresult ;
92963   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92964   int arg2 ;
92965   int arg3 ;
92966   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92967
92968   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92969   arg2 = (int)jarg2;
92970   arg3 = (int)jarg3;
92971   {
92972     try {
92973       try {
92974         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);
92975       }
92976       catch(std::out_of_range &_e) {
92977         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92978         return 0;
92979       }
92980       catch(std::invalid_argument &_e) {
92981         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92982         return 0;
92983       }
92984
92985     } catch (std::out_of_range& e) {
92986       {
92987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92988       };
92989     } catch (std::exception& e) {
92990       {
92991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92992       };
92993     } catch (Dali::DaliException e) {
92994       {
92995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92996       };
92997     } catch (...) {
92998       {
92999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93000       };
93001     }
93002   }
93003
93004   jresult = (void *)result;
93005   return jresult;
93006 }
93007
93008
93009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93010   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93011   int arg2 ;
93012   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93013
93014   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93015   arg2 = (int)jarg2;
93016   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93017   if (!arg3) {
93018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93019     return ;
93020   }
93021   {
93022     try {
93023       try {
93024         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);
93025       }
93026       catch(std::out_of_range &_e) {
93027         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93028         return ;
93029       }
93030
93031     } catch (std::out_of_range& e) {
93032       {
93033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93034       };
93035     } catch (std::exception& e) {
93036       {
93037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93038       };
93039     } catch (Dali::DaliException e) {
93040       {
93041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93042       };
93043     } catch (...) {
93044       {
93045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93046       };
93047     }
93048   }
93049
93050 }
93051
93052
93053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93054   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93055   int arg2 ;
93056   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93057
93058   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93059   arg2 = (int)jarg2;
93060   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93061   if (!arg3) {
93062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93063     return ;
93064   }
93065   {
93066     try {
93067       try {
93068         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);
93069       }
93070       catch(std::out_of_range &_e) {
93071         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93072         return ;
93073       }
93074
93075     } catch (std::out_of_range& e) {
93076       {
93077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93078       };
93079     } catch (std::exception& e) {
93080       {
93081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93082       };
93083     } catch (Dali::DaliException e) {
93084       {
93085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93086       };
93087     } catch (...) {
93088       {
93089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93090       };
93091     }
93092   }
93093
93094 }
93095
93096
93097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
93098   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93099   int arg2 ;
93100
93101   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93102   arg2 = (int)jarg2;
93103   {
93104     try {
93105       try {
93106         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
93107       }
93108       catch(std::out_of_range &_e) {
93109         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93110         return ;
93111       }
93112
93113     } catch (std::out_of_range& e) {
93114       {
93115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93116       };
93117     } catch (std::exception& e) {
93118       {
93119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93120       };
93121     } catch (Dali::DaliException e) {
93122       {
93123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93124       };
93125     } catch (...) {
93126       {
93127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93128       };
93129     }
93130   }
93131
93132 }
93133
93134
93135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93136   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93137   int arg2 ;
93138   int arg3 ;
93139
93140   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93141   arg2 = (int)jarg2;
93142   arg3 = (int)jarg3;
93143   {
93144     try {
93145       try {
93146         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
93147       }
93148       catch(std::out_of_range &_e) {
93149         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93150         return ;
93151       }
93152       catch(std::invalid_argument &_e) {
93153         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93154         return ;
93155       }
93156
93157     } catch (std::out_of_range& e) {
93158       {
93159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93160       };
93161     } catch (std::exception& e) {
93162       {
93163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93164       };
93165     } catch (Dali::DaliException e) {
93166       {
93167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93168       };
93169     } catch (...) {
93170       {
93171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93172       };
93173     }
93174   }
93175
93176 }
93177
93178
93179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93180   void * jresult ;
93181   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93182   int arg2 ;
93183   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93184
93185   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93186   if (!arg1) {
93187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93188     return 0;
93189   }
93190   arg2 = (int)jarg2;
93191   {
93192     try {
93193       try {
93194         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);
93195       }
93196       catch(std::out_of_range &_e) {
93197         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93198         return 0;
93199       }
93200
93201     } catch (std::out_of_range& e) {
93202       {
93203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93204       };
93205     } catch (std::exception& e) {
93206       {
93207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93208       };
93209     } catch (Dali::DaliException e) {
93210       {
93211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93212       };
93213     } catch (...) {
93214       {
93215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93216       };
93217     }
93218   }
93219
93220   jresult = (void *)result;
93221   return jresult;
93222 }
93223
93224
93225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
93226   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93227
93228   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93229   {
93230     try {
93231       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
93232     } catch (std::out_of_range& e) {
93233       {
93234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93235       };
93236     } catch (std::exception& e) {
93237       {
93238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93239       };
93240     } catch (Dali::DaliException e) {
93241       {
93242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93243       };
93244     } catch (...) {
93245       {
93246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93247       };
93248     }
93249   }
93250
93251 }
93252
93253
93254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93255   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93256   int arg2 ;
93257   int arg3 ;
93258
93259   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93260   arg2 = (int)jarg2;
93261   arg3 = (int)jarg3;
93262   {
93263     try {
93264       try {
93265         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93266       }
93267       catch(std::out_of_range &_e) {
93268         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93269         return ;
93270       }
93271       catch(std::invalid_argument &_e) {
93272         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93273         return ;
93274       }
93275
93276     } catch (std::out_of_range& e) {
93277       {
93278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93279       };
93280     } catch (std::exception& e) {
93281       {
93282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93283       };
93284     } catch (Dali::DaliException e) {
93285       {
93286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93287       };
93288     } catch (...) {
93289       {
93290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93291       };
93292     }
93293   }
93294
93295 }
93296
93297
93298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93299   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93300   int arg2 ;
93301   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93302
93303   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93304   arg2 = (int)jarg2;
93305   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93306   if (!arg3) {
93307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93308     return ;
93309   }
93310   {
93311     try {
93312       try {
93313         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);
93314       }
93315       catch(std::out_of_range &_e) {
93316         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93317         return ;
93318       }
93319
93320     } catch (std::out_of_range& e) {
93321       {
93322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93323       };
93324     } catch (std::exception& e) {
93325       {
93326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93327       };
93328     } catch (Dali::DaliException e) {
93329       {
93330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93331       };
93332     } catch (...) {
93333       {
93334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93335       };
93336     }
93337   }
93338
93339 }
93340
93341
93342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
93343   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93344
93345   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93346   {
93347     try {
93348       delete arg1;
93349     } catch (std::out_of_range& e) {
93350       {
93351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93352       };
93353     } catch (std::exception& e) {
93354       {
93355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93356       };
93357     } catch (Dali::DaliException e) {
93358       {
93359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93360       };
93361     } catch (...) {
93362       {
93363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93364       };
93365     }
93366   }
93367
93368 }
93369
93370
93371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
93372   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93373
93374   arg1 = (std::vector< Dali::Actor > *)jarg1;
93375   {
93376     try {
93377       (arg1)->clear();
93378     } catch (std::out_of_range& e) {
93379       {
93380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93381       };
93382     } catch (std::exception& e) {
93383       {
93384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93385       };
93386     } catch (Dali::DaliException e) {
93387       {
93388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93389       };
93390     } catch (...) {
93391       {
93392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93393       };
93394     }
93395   }
93396
93397 }
93398
93399
93400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
93401   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93402   Dali::Actor *arg2 = 0 ;
93403
93404   arg1 = (std::vector< Dali::Actor > *)jarg1;
93405   arg2 = (Dali::Actor *)jarg2;
93406   if (!arg2) {
93407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93408     return ;
93409   }
93410   {
93411     try {
93412       (arg1)->push_back((Dali::Actor const &)*arg2);
93413     } catch (std::out_of_range& e) {
93414       {
93415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93416       };
93417     } catch (std::exception& e) {
93418       {
93419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93420       };
93421     } catch (Dali::DaliException e) {
93422       {
93423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93424       };
93425     } catch (...) {
93426       {
93427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93428       };
93429     }
93430   }
93431
93432 }
93433
93434
93435 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
93436   unsigned long jresult ;
93437   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93438   std::vector< Dali::Actor >::size_type result;
93439
93440   arg1 = (std::vector< Dali::Actor > *)jarg1;
93441   {
93442     try {
93443       result = ((std::vector< Dali::Actor > const *)arg1)->size();
93444     } catch (std::out_of_range& e) {
93445       {
93446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93447       };
93448     } catch (std::exception& e) {
93449       {
93450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93451       };
93452     } catch (Dali::DaliException e) {
93453       {
93454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93455       };
93456     } catch (...) {
93457       {
93458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93459       };
93460     }
93461   }
93462
93463   jresult = (unsigned long)result;
93464   return jresult;
93465 }
93466
93467
93468 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
93469   unsigned long jresult ;
93470   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93471   std::vector< Dali::Actor >::size_type result;
93472
93473   arg1 = (std::vector< Dali::Actor > *)jarg1;
93474   {
93475     try {
93476       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
93477     } catch (std::out_of_range& e) {
93478       {
93479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93480       };
93481     } catch (std::exception& e) {
93482       {
93483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93484       };
93485     } catch (Dali::DaliException e) {
93486       {
93487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93488       };
93489     } catch (...) {
93490       {
93491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93492       };
93493     }
93494   }
93495
93496   jresult = (unsigned long)result;
93497   return jresult;
93498 }
93499
93500
93501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
93502   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93503   std::vector< Dali::Actor >::size_type arg2 ;
93504
93505   arg1 = (std::vector< Dali::Actor > *)jarg1;
93506   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
93507   {
93508     try {
93509       (arg1)->reserve(arg2);
93510     } catch (std::out_of_range& e) {
93511       {
93512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93513       };
93514     } catch (std::exception& e) {
93515       {
93516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93517       };
93518     } catch (Dali::DaliException e) {
93519       {
93520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93521       };
93522     } catch (...) {
93523       {
93524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93525       };
93526     }
93527   }
93528
93529 }
93530
93531
93532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
93533   void * jresult ;
93534   std::vector< Dali::Actor > *result = 0 ;
93535
93536   {
93537     try {
93538       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
93539     } catch (std::out_of_range& e) {
93540       {
93541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93542       };
93543     } catch (std::exception& e) {
93544       {
93545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93546       };
93547     } catch (Dali::DaliException e) {
93548       {
93549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93550       };
93551     } catch (...) {
93552       {
93553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93554       };
93555     }
93556   }
93557
93558   jresult = (void *)result;
93559   return jresult;
93560 }
93561
93562
93563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
93564   void * jresult ;
93565   std::vector< Dali::Actor > *arg1 = 0 ;
93566   std::vector< Dali::Actor > *result = 0 ;
93567
93568   arg1 = (std::vector< Dali::Actor > *)jarg1;
93569   if (!arg1) {
93570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93571     return 0;
93572   }
93573   {
93574     try {
93575       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
93576     } catch (std::out_of_range& e) {
93577       {
93578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93579       };
93580     } catch (std::exception& e) {
93581       {
93582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93583       };
93584     } catch (Dali::DaliException e) {
93585       {
93586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93587       };
93588     } catch (...) {
93589       {
93590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93591       };
93592     }
93593   }
93594
93595   jresult = (void *)result;
93596   return jresult;
93597 }
93598
93599
93600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
93601   void * jresult ;
93602   int arg1 ;
93603   std::vector< Dali::Actor > *result = 0 ;
93604
93605   arg1 = (int)jarg1;
93606   {
93607     try {
93608       try {
93609         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
93610       }
93611       catch(std::out_of_range &_e) {
93612         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93613         return 0;
93614       }
93615
93616     } catch (std::out_of_range& e) {
93617       {
93618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93619       };
93620     } catch (std::exception& e) {
93621       {
93622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93623       };
93624     } catch (Dali::DaliException e) {
93625       {
93626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93627       };
93628     } catch (...) {
93629       {
93630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93631       };
93632     }
93633   }
93634
93635   jresult = (void *)result;
93636   return jresult;
93637 }
93638
93639
93640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
93641   void * jresult ;
93642   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93643   int arg2 ;
93644   Dali::Actor result;
93645
93646   arg1 = (std::vector< Dali::Actor > *)jarg1;
93647   arg2 = (int)jarg2;
93648   {
93649     try {
93650       try {
93651         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
93652       }
93653       catch(std::out_of_range &_e) {
93654         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93655         return 0;
93656       }
93657
93658     } catch (std::out_of_range& e) {
93659       {
93660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93661       };
93662     } catch (std::exception& e) {
93663       {
93664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93665       };
93666     } catch (Dali::DaliException e) {
93667       {
93668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93669       };
93670     } catch (...) {
93671       {
93672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93673       };
93674     }
93675   }
93676
93677   jresult = new Dali::Actor((const Dali::Actor &)result);
93678   return jresult;
93679 }
93680
93681
93682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
93683   void * jresult ;
93684   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93685   int arg2 ;
93686   Dali::Actor *result = 0 ;
93687
93688   arg1 = (std::vector< Dali::Actor > *)jarg1;
93689   arg2 = (int)jarg2;
93690   {
93691     try {
93692       try {
93693         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
93694       }
93695       catch(std::out_of_range &_e) {
93696         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93697         return 0;
93698       }
93699
93700     } catch (std::out_of_range& e) {
93701       {
93702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93703       };
93704     } catch (std::exception& e) {
93705       {
93706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93707       };
93708     } catch (Dali::DaliException e) {
93709       {
93710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93711       };
93712     } catch (...) {
93713       {
93714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93715       };
93716     }
93717   }
93718
93719   jresult = (void *)result;
93720   return jresult;
93721 }
93722
93723
93724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93725   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93726   int arg2 ;
93727   Dali::Actor *arg3 = 0 ;
93728
93729   arg1 = (std::vector< Dali::Actor > *)jarg1;
93730   arg2 = (int)jarg2;
93731   arg3 = (Dali::Actor *)jarg3;
93732   if (!arg3) {
93733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93734     return ;
93735   }
93736   {
93737     try {
93738       try {
93739         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
93740       }
93741       catch(std::out_of_range &_e) {
93742         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93743         return ;
93744       }
93745
93746     } catch (std::out_of_range& e) {
93747       {
93748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93749       };
93750     } catch (std::exception& e) {
93751       {
93752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93753       };
93754     } catch (Dali::DaliException e) {
93755       {
93756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93757       };
93758     } catch (...) {
93759       {
93760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93761       };
93762     }
93763   }
93764
93765 }
93766
93767
93768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
93769   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93770   std::vector< Dali::Actor > *arg2 = 0 ;
93771
93772   arg1 = (std::vector< Dali::Actor > *)jarg1;
93773   arg2 = (std::vector< Dali::Actor > *)jarg2;
93774   if (!arg2) {
93775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93776     return ;
93777   }
93778   {
93779     try {
93780       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
93781     } catch (std::out_of_range& e) {
93782       {
93783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93784       };
93785     } catch (std::exception& e) {
93786       {
93787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93788       };
93789     } catch (Dali::DaliException e) {
93790       {
93791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93792       };
93793     } catch (...) {
93794       {
93795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93796       };
93797     }
93798   }
93799
93800 }
93801
93802
93803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93804   void * jresult ;
93805   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93806   int arg2 ;
93807   int arg3 ;
93808   std::vector< Dali::Actor > *result = 0 ;
93809
93810   arg1 = (std::vector< Dali::Actor > *)jarg1;
93811   arg2 = (int)jarg2;
93812   arg3 = (int)jarg3;
93813   {
93814     try {
93815       try {
93816         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
93817       }
93818       catch(std::out_of_range &_e) {
93819         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93820         return 0;
93821       }
93822       catch(std::invalid_argument &_e) {
93823         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93824         return 0;
93825       }
93826
93827     } catch (std::out_of_range& e) {
93828       {
93829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93830       };
93831     } catch (std::exception& e) {
93832       {
93833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93834       };
93835     } catch (Dali::DaliException e) {
93836       {
93837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93838       };
93839     } catch (...) {
93840       {
93841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93842       };
93843     }
93844   }
93845
93846   jresult = (void *)result;
93847   return jresult;
93848 }
93849
93850
93851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93852   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93853   int arg2 ;
93854   Dali::Actor *arg3 = 0 ;
93855
93856   arg1 = (std::vector< Dali::Actor > *)jarg1;
93857   arg2 = (int)jarg2;
93858   arg3 = (Dali::Actor *)jarg3;
93859   if (!arg3) {
93860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93861     return ;
93862   }
93863   {
93864     try {
93865       try {
93866         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
93867       }
93868       catch(std::out_of_range &_e) {
93869         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93870         return ;
93871       }
93872
93873     } catch (std::out_of_range& e) {
93874       {
93875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93876       };
93877     } catch (std::exception& e) {
93878       {
93879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93880       };
93881     } catch (Dali::DaliException e) {
93882       {
93883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93884       };
93885     } catch (...) {
93886       {
93887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93888       };
93889     }
93890   }
93891
93892 }
93893
93894
93895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93896   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93897   int arg2 ;
93898   std::vector< Dali::Actor > *arg3 = 0 ;
93899
93900   arg1 = (std::vector< Dali::Actor > *)jarg1;
93901   arg2 = (int)jarg2;
93902   arg3 = (std::vector< Dali::Actor > *)jarg3;
93903   if (!arg3) {
93904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93905     return ;
93906   }
93907   {
93908     try {
93909       try {
93910         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93911       }
93912       catch(std::out_of_range &_e) {
93913         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93914         return ;
93915       }
93916
93917     } catch (std::out_of_range& e) {
93918       {
93919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93920       };
93921     } catch (std::exception& e) {
93922       {
93923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93924       };
93925     } catch (Dali::DaliException e) {
93926       {
93927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93928       };
93929     } catch (...) {
93930       {
93931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93932       };
93933     }
93934   }
93935
93936 }
93937
93938
93939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
93940   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93941   int arg2 ;
93942
93943   arg1 = (std::vector< Dali::Actor > *)jarg1;
93944   arg2 = (int)jarg2;
93945   {
93946     try {
93947       try {
93948         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
93949       }
93950       catch(std::out_of_range &_e) {
93951         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93952         return ;
93953       }
93954
93955     } catch (std::out_of_range& e) {
93956       {
93957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93958       };
93959     } catch (std::exception& e) {
93960       {
93961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93962       };
93963     } catch (Dali::DaliException e) {
93964       {
93965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93966       };
93967     } catch (...) {
93968       {
93969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93970       };
93971     }
93972   }
93973
93974 }
93975
93976
93977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93978   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93979   int arg2 ;
93980   int arg3 ;
93981
93982   arg1 = (std::vector< Dali::Actor > *)jarg1;
93983   arg2 = (int)jarg2;
93984   arg3 = (int)jarg3;
93985   {
93986     try {
93987       try {
93988         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
93989       }
93990       catch(std::out_of_range &_e) {
93991         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93992         return ;
93993       }
93994       catch(std::invalid_argument &_e) {
93995         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93996         return ;
93997       }
93998
93999     } catch (std::out_of_range& e) {
94000       {
94001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94002       };
94003     } catch (std::exception& e) {
94004       {
94005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94006       };
94007     } catch (Dali::DaliException e) {
94008       {
94009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94010       };
94011     } catch (...) {
94012       {
94013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94014       };
94015     }
94016   }
94017
94018 }
94019
94020
94021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
94022   void * jresult ;
94023   Dali::Actor *arg1 = 0 ;
94024   int arg2 ;
94025   std::vector< Dali::Actor > *result = 0 ;
94026
94027   arg1 = (Dali::Actor *)jarg1;
94028   if (!arg1) {
94029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94030     return 0;
94031   }
94032   arg2 = (int)jarg2;
94033   {
94034     try {
94035       try {
94036         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
94037       }
94038       catch(std::out_of_range &_e) {
94039         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94040         return 0;
94041       }
94042
94043     } catch (std::out_of_range& e) {
94044       {
94045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94046       };
94047     } catch (std::exception& e) {
94048       {
94049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94050       };
94051     } catch (Dali::DaliException e) {
94052       {
94053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94054       };
94055     } catch (...) {
94056       {
94057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94058       };
94059     }
94060   }
94061
94062   jresult = (void *)result;
94063   return jresult;
94064 }
94065
94066
94067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
94068   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94069
94070   arg1 = (std::vector< Dali::Actor > *)jarg1;
94071   {
94072     try {
94073       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
94074     } catch (std::out_of_range& e) {
94075       {
94076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94077       };
94078     } catch (std::exception& e) {
94079       {
94080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94081       };
94082     } catch (Dali::DaliException e) {
94083       {
94084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94085       };
94086     } catch (...) {
94087       {
94088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94089       };
94090     }
94091   }
94092
94093 }
94094
94095
94096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94097   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94098   int arg2 ;
94099   int arg3 ;
94100
94101   arg1 = (std::vector< Dali::Actor > *)jarg1;
94102   arg2 = (int)jarg2;
94103   arg3 = (int)jarg3;
94104   {
94105     try {
94106       try {
94107         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94108       }
94109       catch(std::out_of_range &_e) {
94110         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94111         return ;
94112       }
94113       catch(std::invalid_argument &_e) {
94114         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94115         return ;
94116       }
94117
94118     } catch (std::out_of_range& e) {
94119       {
94120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94121       };
94122     } catch (std::exception& e) {
94123       {
94124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94125       };
94126     } catch (Dali::DaliException e) {
94127       {
94128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94129       };
94130     } catch (...) {
94131       {
94132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94133       };
94134     }
94135   }
94136
94137 }
94138
94139
94140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94141   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94142   int arg2 ;
94143   std::vector< Dali::Actor > *arg3 = 0 ;
94144
94145   arg1 = (std::vector< Dali::Actor > *)jarg1;
94146   arg2 = (int)jarg2;
94147   arg3 = (std::vector< Dali::Actor > *)jarg3;
94148   if (!arg3) {
94149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94150     return ;
94151   }
94152   {
94153     try {
94154       try {
94155         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94156       }
94157       catch(std::out_of_range &_e) {
94158         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94159         return ;
94160       }
94161
94162     } catch (std::out_of_range& e) {
94163       {
94164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94165       };
94166     } catch (std::exception& e) {
94167       {
94168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94169       };
94170     } catch (Dali::DaliException e) {
94171       {
94172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94173       };
94174     } catch (...) {
94175       {
94176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94177       };
94178     }
94179   }
94180
94181 }
94182
94183
94184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94185   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94186
94187   arg1 = (std::vector< Dali::Actor > *)jarg1;
94188   {
94189     try {
94190       delete arg1;
94191     } catch (std::out_of_range& e) {
94192       {
94193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94194       };
94195     } catch (std::exception& e) {
94196       {
94197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94198       };
94199     } catch (Dali::DaliException e) {
94200       {
94201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94202       };
94203     } catch (...) {
94204       {
94205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94206       };
94207     }
94208   }
94209
94210 }
94211
94212
94213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94214   unsigned int jresult ;
94215   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94216   bool result;
94217
94218   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94219   {
94220     try {
94221       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94222     } catch (std::out_of_range& e) {
94223       {
94224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94225       };
94226     } catch (std::exception& e) {
94227       {
94228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94229       };
94230     } catch (Dali::DaliException e) {
94231       {
94232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94233       };
94234     } catch (...) {
94235       {
94236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94237       };
94238     }
94239   }
94240
94241   jresult = result;
94242   return jresult;
94243 }
94244
94245
94246 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
94247   unsigned long jresult ;
94248   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94249   std::size_t result;
94250
94251   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94252   {
94253     try {
94254       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94255     } catch (std::out_of_range& e) {
94256       {
94257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94258       };
94259     } catch (std::exception& e) {
94260       {
94261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94262       };
94263     } catch (Dali::DaliException e) {
94264       {
94265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94266       };
94267     } catch (...) {
94268       {
94269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94270       };
94271     }
94272   }
94273
94274   jresult = (unsigned long)result;
94275   return jresult;
94276 }
94277
94278
94279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
94280   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94281   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94282
94283   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94284   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94285   {
94286     try {
94287       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
94288     } catch (std::out_of_range& e) {
94289       {
94290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94291       };
94292     } catch (std::exception& e) {
94293       {
94294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94295       };
94296     } catch (Dali::DaliException e) {
94297       {
94298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94299       };
94300     } catch (...) {
94301       {
94302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94303       };
94304     }
94305   }
94306
94307 }
94308
94309
94310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
94311   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94312   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94313
94314   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94315   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94316   {
94317     try {
94318       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
94319     } catch (std::out_of_range& e) {
94320       {
94321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94322       };
94323     } catch (std::exception& e) {
94324       {
94325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94326       };
94327     } catch (Dali::DaliException e) {
94328       {
94329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94330       };
94331     } catch (...) {
94332       {
94333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94334       };
94335     }
94336   }
94337
94338 }
94339
94340
94341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
94342   unsigned int jresult ;
94343   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94344   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
94345   bool result;
94346
94347   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94348   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
94349   if (!arg2) {
94350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
94351     return 0;
94352   }
94353   {
94354     try {
94355       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
94356     } catch (std::out_of_range& e) {
94357       {
94358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94359       };
94360     } catch (std::exception& e) {
94361       {
94362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94363       };
94364     } catch (Dali::DaliException e) {
94365       {
94366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94367       };
94368     } catch (...) {
94369       {
94370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94371       };
94372     }
94373   }
94374
94375   jresult = result;
94376   return jresult;
94377 }
94378
94379
94380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
94381   void * jresult ;
94382   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
94383
94384   {
94385     try {
94386       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
94387     } catch (std::out_of_range& e) {
94388       {
94389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94390       };
94391     } catch (std::exception& e) {
94392       {
94393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94394       };
94395     } catch (Dali::DaliException e) {
94396       {
94397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94398       };
94399     } catch (...) {
94400       {
94401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94402       };
94403     }
94404   }
94405
94406   jresult = (void *)result;
94407   return jresult;
94408 }
94409
94410
94411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
94412   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94413
94414   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94415   {
94416     try {
94417       delete arg1;
94418     } catch (std::out_of_range& e) {
94419       {
94420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94421       };
94422     } catch (std::exception& e) {
94423       {
94424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94425       };
94426     } catch (Dali::DaliException e) {
94427       {
94428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94429       };
94430     } catch (...) {
94431       {
94432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94433       };
94434     }
94435   }
94436
94437 }
94438
94439
94440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
94441   unsigned int jresult ;
94442   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94443   bool result;
94444
94445   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94446   {
94447     try {
94448       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);
94449     } catch (std::out_of_range& e) {
94450       {
94451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94452       };
94453     } catch (std::exception& e) {
94454       {
94455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94456       };
94457     } catch (Dali::DaliException e) {
94458       {
94459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94460       };
94461     } catch (...) {
94462       {
94463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94464       };
94465     }
94466   }
94467
94468   jresult = result;
94469   return jresult;
94470 }
94471
94472
94473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
94474   unsigned long jresult ;
94475   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94476   std::size_t result;
94477
94478   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94479   {
94480     try {
94481       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);
94482     } catch (std::out_of_range& e) {
94483       {
94484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94485       };
94486     } catch (std::exception& e) {
94487       {
94488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94489       };
94490     } catch (Dali::DaliException e) {
94491       {
94492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94493       };
94494     } catch (...) {
94495       {
94496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94497       };
94498     }
94499   }
94500
94501   jresult = (unsigned long)result;
94502   return jresult;
94503 }
94504
94505
94506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
94507   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94508   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94509
94510   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94511   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94512   {
94513     try {
94514       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
94515     } catch (std::out_of_range& e) {
94516       {
94517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94518       };
94519     } catch (std::exception& e) {
94520       {
94521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94522       };
94523     } catch (Dali::DaliException e) {
94524       {
94525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94526       };
94527     } catch (...) {
94528       {
94529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94530       };
94531     }
94532   }
94533
94534 }
94535
94536
94537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
94538   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94539   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94540
94541   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94542   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94543   {
94544     try {
94545       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
94546     } catch (std::out_of_range& e) {
94547       {
94548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94549       };
94550     } catch (std::exception& e) {
94551       {
94552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94553       };
94554     } catch (Dali::DaliException e) {
94555       {
94556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94557       };
94558     } catch (...) {
94559       {
94560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94561       };
94562     }
94563   }
94564
94565 }
94566
94567
94568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94569   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94570   Dali::Actor arg2 ;
94571   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
94572   Dali::Actor *argp2 ;
94573
94574   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94575   argp2 = (Dali::Actor *)jarg2;
94576   if (!argp2) {
94577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94578     return ;
94579   }
94580   arg2 = *argp2;
94581   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
94582   {
94583     try {
94584       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
94585     } catch (std::out_of_range& e) {
94586       {
94587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94588       };
94589     } catch (std::exception& e) {
94590       {
94591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94592       };
94593     } catch (Dali::DaliException e) {
94594       {
94595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94596       };
94597     } catch (...) {
94598       {
94599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94600       };
94601     }
94602   }
94603
94604 }
94605
94606
94607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
94608   void * jresult ;
94609   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
94610
94611   {
94612     try {
94613       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
94614     } catch (std::out_of_range& e) {
94615       {
94616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94617       };
94618     } catch (std::exception& e) {
94619       {
94620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94621       };
94622     } catch (Dali::DaliException e) {
94623       {
94624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94625       };
94626     } catch (...) {
94627       {
94628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94629       };
94630     }
94631   }
94632
94633   jresult = (void *)result;
94634   return jresult;
94635 }
94636
94637
94638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
94639   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94640
94641   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94642   {
94643     try {
94644       delete arg1;
94645     } catch (std::out_of_range& e) {
94646       {
94647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94648       };
94649     } catch (std::exception& e) {
94650       {
94651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94652       };
94653     } catch (Dali::DaliException e) {
94654       {
94655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94656       };
94657     } catch (...) {
94658       {
94659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94660       };
94661     }
94662   }
94663
94664 }
94665
94666
94667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
94668   unsigned int jresult ;
94669   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94670   bool result;
94671
94672   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94673   {
94674     try {
94675       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94676     } catch (std::out_of_range& e) {
94677       {
94678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94679       };
94680     } catch (std::exception& e) {
94681       {
94682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94683       };
94684     } catch (Dali::DaliException e) {
94685       {
94686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94687       };
94688     } catch (...) {
94689       {
94690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94691       };
94692     }
94693   }
94694
94695   jresult = result;
94696   return jresult;
94697 }
94698
94699
94700 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
94701   unsigned long jresult ;
94702   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94703   std::size_t result;
94704
94705   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94706   {
94707     try {
94708       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94709     } catch (std::out_of_range& e) {
94710       {
94711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94712       };
94713     } catch (std::exception& e) {
94714       {
94715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94716       };
94717     } catch (Dali::DaliException e) {
94718       {
94719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94720       };
94721     } catch (...) {
94722       {
94723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94724       };
94725     }
94726   }
94727
94728   jresult = (unsigned long)result;
94729   return jresult;
94730 }
94731
94732
94733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
94734   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94735   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94736
94737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94738   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94739   {
94740     try {
94741       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
94742     } catch (std::out_of_range& e) {
94743       {
94744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94745       };
94746     } catch (std::exception& e) {
94747       {
94748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94749       };
94750     } catch (Dali::DaliException e) {
94751       {
94752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94753       };
94754     } catch (...) {
94755       {
94756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94757       };
94758     }
94759   }
94760
94761 }
94762
94763
94764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94765   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94766   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94767
94768   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94769   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94770   {
94771     try {
94772       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
94773     } catch (std::out_of_range& e) {
94774       {
94775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94776       };
94777     } catch (std::exception& e) {
94778       {
94779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94780       };
94781     } catch (Dali::DaliException e) {
94782       {
94783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94784       };
94785     } catch (...) {
94786       {
94787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94788       };
94789     }
94790   }
94791
94792 }
94793
94794
94795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
94796   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94797   Dali::Actor arg2 ;
94798   Dali::Actor arg3 ;
94799   Dali::Actor *argp2 ;
94800   Dali::Actor *argp3 ;
94801
94802   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94803   argp2 = (Dali::Actor *)jarg2;
94804   if (!argp2) {
94805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94806     return ;
94807   }
94808   arg2 = *argp2;
94809   argp3 = (Dali::Actor *)jarg3;
94810   if (!argp3) {
94811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94812     return ;
94813   }
94814   arg3 = *argp3;
94815   {
94816     try {
94817       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
94818     } catch (std::out_of_range& e) {
94819       {
94820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94821       };
94822     } catch (std::exception& e) {
94823       {
94824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94825       };
94826     } catch (Dali::DaliException e) {
94827       {
94828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94829       };
94830     } catch (...) {
94831       {
94832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94833       };
94834     }
94835   }
94836
94837 }
94838
94839
94840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
94841   void * jresult ;
94842   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
94843
94844   {
94845     try {
94846       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
94847     } catch (std::out_of_range& e) {
94848       {
94849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94850       };
94851     } catch (std::exception& e) {
94852       {
94853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94854       };
94855     } catch (Dali::DaliException e) {
94856       {
94857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94858       };
94859     } catch (...) {
94860       {
94861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94862       };
94863     }
94864   }
94865
94866   jresult = (void *)result;
94867   return jresult;
94868 }
94869
94870
94871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
94872   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94873
94874   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94875   {
94876     try {
94877       delete arg1;
94878     } catch (std::out_of_range& e) {
94879       {
94880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94881       };
94882     } catch (std::exception& e) {
94883       {
94884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94885       };
94886     } catch (Dali::DaliException e) {
94887       {
94888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94889       };
94890     } catch (...) {
94891       {
94892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94893       };
94894     }
94895   }
94896
94897 }
94898
94899
94900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
94901   unsigned int jresult ;
94902   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94903   bool result;
94904
94905   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94906   {
94907     try {
94908       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94909     } catch (std::out_of_range& e) {
94910       {
94911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94912       };
94913     } catch (std::exception& e) {
94914       {
94915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94916       };
94917     } catch (Dali::DaliException e) {
94918       {
94919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94920       };
94921     } catch (...) {
94922       {
94923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94924       };
94925     }
94926   }
94927
94928   jresult = result;
94929   return jresult;
94930 }
94931
94932
94933 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
94934   unsigned long jresult ;
94935   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94936   std::size_t result;
94937
94938   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94939   {
94940     try {
94941       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94942     } catch (std::out_of_range& e) {
94943       {
94944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94945       };
94946     } catch (std::exception& e) {
94947       {
94948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94949       };
94950     } catch (Dali::DaliException e) {
94951       {
94952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94953       };
94954     } catch (...) {
94955       {
94956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94957       };
94958     }
94959   }
94960
94961   jresult = (unsigned long)result;
94962   return jresult;
94963 }
94964
94965
94966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
94967   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94968   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94969
94970   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94971   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94972   {
94973     try {
94974       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
94975     } catch (std::out_of_range& e) {
94976       {
94977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94978       };
94979     } catch (std::exception& e) {
94980       {
94981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94982       };
94983     } catch (Dali::DaliException e) {
94984       {
94985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94986       };
94987     } catch (...) {
94988       {
94989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94990       };
94991     }
94992   }
94993
94994 }
94995
94996
94997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94998   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94999   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95000
95001   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95002   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95003   {
95004     try {
95005       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95006     } catch (std::out_of_range& e) {
95007       {
95008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95009       };
95010     } catch (std::exception& e) {
95011       {
95012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95013       };
95014     } catch (Dali::DaliException e) {
95015       {
95016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95017       };
95018     } catch (...) {
95019       {
95020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95021       };
95022     }
95023   }
95024
95025 }
95026
95027
95028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
95029   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95030   Dali::Actor arg2 ;
95031   bool arg3 ;
95032   Dali::Actor *argp2 ;
95033
95034   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95035   argp2 = (Dali::Actor *)jarg2;
95036   if (!argp2) {
95037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95038     return ;
95039   }
95040   arg2 = *argp2;
95041   arg3 = jarg3 ? true : false;
95042   {
95043     try {
95044       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
95045     } catch (std::out_of_range& e) {
95046       {
95047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95048       };
95049     } catch (std::exception& e) {
95050       {
95051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95052       };
95053     } catch (Dali::DaliException e) {
95054       {
95055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95056       };
95057     } catch (...) {
95058       {
95059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95060       };
95061     }
95062   }
95063
95064 }
95065
95066
95067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
95068   void * jresult ;
95069   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
95070
95071   {
95072     try {
95073       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
95074     } catch (std::out_of_range& e) {
95075       {
95076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95077       };
95078     } catch (std::exception& e) {
95079       {
95080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95081       };
95082     } catch (Dali::DaliException e) {
95083       {
95084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95085       };
95086     } catch (...) {
95087       {
95088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95089       };
95090     }
95091   }
95092
95093   jresult = (void *)result;
95094   return jresult;
95095 }
95096
95097
95098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
95099   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95100
95101   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95102   {
95103     try {
95104       delete arg1;
95105     } catch (std::out_of_range& e) {
95106       {
95107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95108       };
95109     } catch (std::exception& e) {
95110       {
95111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95112       };
95113     } catch (Dali::DaliException e) {
95114       {
95115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95116       };
95117     } catch (...) {
95118       {
95119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95120       };
95121     }
95122   }
95123
95124 }
95125
95126
95127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
95128   unsigned int jresult ;
95129   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95130   bool result;
95131
95132   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95133   {
95134     try {
95135       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);
95136     } catch (std::out_of_range& e) {
95137       {
95138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95139       };
95140     } catch (std::exception& e) {
95141       {
95142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95143       };
95144     } catch (Dali::DaliException e) {
95145       {
95146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95147       };
95148     } catch (...) {
95149       {
95150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95151       };
95152     }
95153   }
95154
95155   jresult = result;
95156   return jresult;
95157 }
95158
95159
95160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95161   unsigned long jresult ;
95162   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95163   std::size_t result;
95164
95165   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95166   {
95167     try {
95168       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);
95169     } catch (std::out_of_range& e) {
95170       {
95171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95172       };
95173     } catch (std::exception& e) {
95174       {
95175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95176       };
95177     } catch (Dali::DaliException e) {
95178       {
95179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95180       };
95181     } catch (...) {
95182       {
95183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95184       };
95185     }
95186   }
95187
95188   jresult = (unsigned long)result;
95189   return jresult;
95190 }
95191
95192
95193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95194   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95195   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95196
95197   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95198   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95199   {
95200     try {
95201       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95202     } catch (std::out_of_range& e) {
95203       {
95204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95205       };
95206     } catch (std::exception& e) {
95207       {
95208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95209       };
95210     } catch (Dali::DaliException e) {
95211       {
95212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95213       };
95214     } catch (...) {
95215       {
95216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95217       };
95218     }
95219   }
95220
95221 }
95222
95223
95224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95225   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95226   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95227
95228   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95229   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95230   {
95231     try {
95232       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
95233     } catch (std::out_of_range& e) {
95234       {
95235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95236       };
95237     } catch (std::exception& e) {
95238       {
95239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95240       };
95241     } catch (Dali::DaliException e) {
95242       {
95243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95244       };
95245     } catch (...) {
95246       {
95247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95248       };
95249     }
95250   }
95251
95252 }
95253
95254
95255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95256   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95257   Dali::Toolkit::StyleManager arg2 ;
95258   Dali::StyleChange::Type arg3 ;
95259   Dali::Toolkit::StyleManager *argp2 ;
95260
95261   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95262   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
95263   if (!argp2) {
95264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
95265     return ;
95266   }
95267   arg2 = *argp2;
95268   arg3 = (Dali::StyleChange::Type)jarg3;
95269   {
95270     try {
95271       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
95272     } catch (std::out_of_range& e) {
95273       {
95274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95275       };
95276     } catch (std::exception& e) {
95277       {
95278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95279       };
95280     } catch (Dali::DaliException e) {
95281       {
95282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95283       };
95284     } catch (...) {
95285       {
95286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95287       };
95288     }
95289   }
95290
95291 }
95292
95293
95294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
95295   void * jresult ;
95296   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
95297
95298   {
95299     try {
95300       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
95301     } catch (std::out_of_range& e) {
95302       {
95303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95304       };
95305     } catch (std::exception& e) {
95306       {
95307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95308       };
95309     } catch (Dali::DaliException e) {
95310       {
95311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95312       };
95313     } catch (...) {
95314       {
95315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95316       };
95317     }
95318   }
95319
95320   jresult = (void *)result;
95321   return jresult;
95322 }
95323
95324
95325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
95326   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95327
95328   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95329   {
95330     try {
95331       delete arg1;
95332     } catch (std::out_of_range& e) {
95333       {
95334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95335       };
95336     } catch (std::exception& e) {
95337       {
95338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95339       };
95340     } catch (Dali::DaliException e) {
95341       {
95342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95343       };
95344     } catch (...) {
95345       {
95346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95347       };
95348     }
95349   }
95350
95351 }
95352
95353
95354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
95355   unsigned int jresult ;
95356   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95357   bool result;
95358
95359   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95360   {
95361     try {
95362       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95363     } catch (std::out_of_range& e) {
95364       {
95365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95366       };
95367     } catch (std::exception& e) {
95368       {
95369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95370       };
95371     } catch (Dali::DaliException e) {
95372       {
95373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95374       };
95375     } catch (...) {
95376       {
95377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95378       };
95379     }
95380   }
95381
95382   jresult = result;
95383   return jresult;
95384 }
95385
95386
95387 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
95388   unsigned long jresult ;
95389   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95390   std::size_t result;
95391
95392   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95393   {
95394     try {
95395       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95396     } catch (std::out_of_range& e) {
95397       {
95398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95399       };
95400     } catch (std::exception& e) {
95401       {
95402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95403       };
95404     } catch (Dali::DaliException e) {
95405       {
95406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95407       };
95408     } catch (...) {
95409       {
95410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95411       };
95412     }
95413   }
95414
95415   jresult = (unsigned long)result;
95416   return jresult;
95417 }
95418
95419
95420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
95421   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95422   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95423
95424   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95425   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95426   {
95427     try {
95428       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
95429     } catch (std::out_of_range& e) {
95430       {
95431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95432       };
95433     } catch (std::exception& e) {
95434       {
95435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95436       };
95437     } catch (Dali::DaliException e) {
95438       {
95439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95440       };
95441     } catch (...) {
95442       {
95443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95444       };
95445     }
95446   }
95447
95448 }
95449
95450
95451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
95452   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95453   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95454
95455   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95456   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95457   {
95458     try {
95459       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
95460     } catch (std::out_of_range& e) {
95461       {
95462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95463       };
95464     } catch (std::exception& e) {
95465       {
95466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95467       };
95468     } catch (Dali::DaliException e) {
95469       {
95470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95471       };
95472     } catch (...) {
95473       {
95474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95475       };
95476     }
95477   }
95478
95479 }
95480
95481
95482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
95483   unsigned int jresult ;
95484   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95485   Dali::Toolkit::Button arg2 ;
95486   Dali::Toolkit::Button *argp2 ;
95487   bool result;
95488
95489   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95490   argp2 = (Dali::Toolkit::Button *)jarg2;
95491   if (!argp2) {
95492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
95493     return 0;
95494   }
95495   arg2 = *argp2;
95496   {
95497     try {
95498       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
95499     } catch (std::out_of_range& e) {
95500       {
95501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95502       };
95503     } catch (std::exception& e) {
95504       {
95505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95506       };
95507     } catch (Dali::DaliException e) {
95508       {
95509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95510       };
95511     } catch (...) {
95512       {
95513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95514       };
95515     }
95516   }
95517
95518   jresult = result;
95519   return jresult;
95520 }
95521
95522
95523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
95524   void * jresult ;
95525   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
95526
95527   {
95528     try {
95529       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
95530     } catch (std::out_of_range& e) {
95531       {
95532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95533       };
95534     } catch (std::exception& e) {
95535       {
95536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95537       };
95538     } catch (Dali::DaliException e) {
95539       {
95540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95541       };
95542     } catch (...) {
95543       {
95544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95545       };
95546     }
95547   }
95548
95549   jresult = (void *)result;
95550   return jresult;
95551 }
95552
95553
95554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
95555   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95556
95557   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95558   {
95559     try {
95560       delete arg1;
95561     } catch (std::out_of_range& e) {
95562       {
95563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95564       };
95565     } catch (std::exception& e) {
95566       {
95567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95568       };
95569     } catch (Dali::DaliException e) {
95570       {
95571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95572       };
95573     } catch (...) {
95574       {
95575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95576       };
95577     }
95578   }
95579
95580 }
95581
95582
95583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
95584   unsigned int jresult ;
95585   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95586   bool result;
95587
95588   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95589   {
95590     try {
95591       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95592     } catch (std::out_of_range& e) {
95593       {
95594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95595       };
95596     } catch (std::exception& e) {
95597       {
95598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95599       };
95600     } catch (Dali::DaliException e) {
95601       {
95602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95603       };
95604     } catch (...) {
95605       {
95606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95607       };
95608     }
95609   }
95610
95611   jresult = result;
95612   return jresult;
95613 }
95614
95615
95616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
95617   unsigned long jresult ;
95618   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95619   std::size_t result;
95620
95621   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95622   {
95623     try {
95624       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95625     } catch (std::out_of_range& e) {
95626       {
95627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95628       };
95629     } catch (std::exception& e) {
95630       {
95631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95632       };
95633     } catch (Dali::DaliException e) {
95634       {
95635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95636       };
95637     } catch (...) {
95638       {
95639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95640       };
95641     }
95642   }
95643
95644   jresult = (unsigned long)result;
95645   return jresult;
95646 }
95647
95648
95649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
95650   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95651   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95652
95653   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95654   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95655   {
95656     try {
95657       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
95658     } catch (std::out_of_range& e) {
95659       {
95660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95661       };
95662     } catch (std::exception& e) {
95663       {
95664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95665       };
95666     } catch (Dali::DaliException e) {
95667       {
95668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95669       };
95670     } catch (...) {
95671       {
95672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95673       };
95674     }
95675   }
95676
95677 }
95678
95679
95680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
95681   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95682   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95683
95684   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95685   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95686   {
95687     try {
95688       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
95689     } catch (std::out_of_range& e) {
95690       {
95691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95692       };
95693     } catch (std::exception& e) {
95694       {
95695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95696       };
95697     } catch (Dali::DaliException e) {
95698       {
95699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95700       };
95701     } catch (...) {
95702       {
95703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95704       };
95705     }
95706   }
95707
95708 }
95709
95710
95711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
95712   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95713   Dali::Toolkit::GaussianBlurView arg2 ;
95714   Dali::Toolkit::GaussianBlurView *argp2 ;
95715
95716   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95717   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
95718   if (!argp2) {
95719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
95720     return ;
95721   }
95722   arg2 = *argp2;
95723   {
95724     try {
95725       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
95726     } catch (std::out_of_range& e) {
95727       {
95728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95729       };
95730     } catch (std::exception& e) {
95731       {
95732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95733       };
95734     } catch (Dali::DaliException e) {
95735       {
95736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95737       };
95738     } catch (...) {
95739       {
95740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95741       };
95742     }
95743   }
95744
95745 }
95746
95747
95748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
95749   void * jresult ;
95750   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
95751
95752   {
95753     try {
95754       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
95755     } catch (std::out_of_range& e) {
95756       {
95757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95758       };
95759     } catch (std::exception& e) {
95760       {
95761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95762       };
95763     } catch (Dali::DaliException e) {
95764       {
95765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95766       };
95767     } catch (...) {
95768       {
95769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95770       };
95771     }
95772   }
95773
95774   jresult = (void *)result;
95775   return jresult;
95776 }
95777
95778
95779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
95780   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95781
95782   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95783   {
95784     try {
95785       delete arg1;
95786     } catch (std::out_of_range& e) {
95787       {
95788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95789       };
95790     } catch (std::exception& e) {
95791       {
95792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95793       };
95794     } catch (Dali::DaliException e) {
95795       {
95796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95797       };
95798     } catch (...) {
95799       {
95800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95801       };
95802     }
95803   }
95804
95805 }
95806
95807
95808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
95809   unsigned int jresult ;
95810   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95811   bool result;
95812
95813   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95814   {
95815     try {
95816       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);
95817     } catch (std::out_of_range& e) {
95818       {
95819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95820       };
95821     } catch (std::exception& e) {
95822       {
95823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95824       };
95825     } catch (Dali::DaliException e) {
95826       {
95827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95828       };
95829     } catch (...) {
95830       {
95831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95832       };
95833     }
95834   }
95835
95836   jresult = result;
95837   return jresult;
95838 }
95839
95840
95841 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
95842   unsigned long jresult ;
95843   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95844   std::size_t result;
95845
95846   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95847   {
95848     try {
95849       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);
95850     } catch (std::out_of_range& e) {
95851       {
95852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95853       };
95854     } catch (std::exception& e) {
95855       {
95856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95857       };
95858     } catch (Dali::DaliException e) {
95859       {
95860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95861       };
95862     } catch (...) {
95863       {
95864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95865       };
95866     }
95867   }
95868
95869   jresult = (unsigned long)result;
95870   return jresult;
95871 }
95872
95873
95874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
95875   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95876   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95877
95878   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95879   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95880   {
95881     try {
95882       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
95883     } catch (std::out_of_range& e) {
95884       {
95885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95886       };
95887     } catch (std::exception& e) {
95888       {
95889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95890       };
95891     } catch (Dali::DaliException e) {
95892       {
95893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95894       };
95895     } catch (...) {
95896       {
95897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95898       };
95899     }
95900   }
95901
95902 }
95903
95904
95905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
95906   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95907   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95908
95909   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95910   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95911   {
95912     try {
95913       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95914     } catch (std::out_of_range& e) {
95915       {
95916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95917       };
95918     } catch (std::exception& e) {
95919       {
95920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95921       };
95922     } catch (Dali::DaliException e) {
95923       {
95924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95925       };
95926     } catch (...) {
95927       {
95928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95929       };
95930     }
95931   }
95932
95933 }
95934
95935
95936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
95937   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95938   Dali::Toolkit::PageTurnView arg2 ;
95939   unsigned int arg3 ;
95940   bool arg4 ;
95941   Dali::Toolkit::PageTurnView *argp2 ;
95942
95943   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95944   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
95945   if (!argp2) {
95946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
95947     return ;
95948   }
95949   arg2 = *argp2;
95950   arg3 = (unsigned int)jarg3;
95951   arg4 = jarg4 ? true : false;
95952   {
95953     try {
95954       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
95955     } catch (std::out_of_range& e) {
95956       {
95957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95958       };
95959     } catch (std::exception& e) {
95960       {
95961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95962       };
95963     } catch (Dali::DaliException e) {
95964       {
95965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95966       };
95967     } catch (...) {
95968       {
95969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95970       };
95971     }
95972   }
95973
95974 }
95975
95976
95977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
95978   void * jresult ;
95979   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
95980
95981   {
95982     try {
95983       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
95984     } catch (std::out_of_range& e) {
95985       {
95986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95987       };
95988     } catch (std::exception& e) {
95989       {
95990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95991       };
95992     } catch (Dali::DaliException e) {
95993       {
95994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95995       };
95996     } catch (...) {
95997       {
95998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95999       };
96000     }
96001   }
96002
96003   jresult = (void *)result;
96004   return jresult;
96005 }
96006
96007
96008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
96009   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96010
96011   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96012   {
96013     try {
96014       delete arg1;
96015     } catch (std::out_of_range& e) {
96016       {
96017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96018       };
96019     } catch (std::exception& e) {
96020       {
96021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96022       };
96023     } catch (Dali::DaliException e) {
96024       {
96025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96026       };
96027     } catch (...) {
96028       {
96029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96030       };
96031     }
96032   }
96033
96034 }
96035
96036
96037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
96038   unsigned int jresult ;
96039   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96040   bool result;
96041
96042   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96043   {
96044     try {
96045       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96046     } catch (std::out_of_range& e) {
96047       {
96048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96049       };
96050     } catch (std::exception& e) {
96051       {
96052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96053       };
96054     } catch (Dali::DaliException e) {
96055       {
96056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96057       };
96058     } catch (...) {
96059       {
96060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96061       };
96062     }
96063   }
96064
96065   jresult = result;
96066   return jresult;
96067 }
96068
96069
96070 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
96071   unsigned long jresult ;
96072   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96073   std::size_t result;
96074
96075   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96076   {
96077     try {
96078       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96079     } catch (std::out_of_range& e) {
96080       {
96081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96082       };
96083     } catch (std::exception& e) {
96084       {
96085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96086       };
96087     } catch (Dali::DaliException e) {
96088       {
96089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96090       };
96091     } catch (...) {
96092       {
96093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96094       };
96095     }
96096   }
96097
96098   jresult = (unsigned long)result;
96099   return jresult;
96100 }
96101
96102
96103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
96104   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96105   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96106
96107   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96108   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96109   {
96110     try {
96111       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
96112     } catch (std::out_of_range& e) {
96113       {
96114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96115       };
96116     } catch (std::exception& e) {
96117       {
96118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96119       };
96120     } catch (Dali::DaliException e) {
96121       {
96122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96123       };
96124     } catch (...) {
96125       {
96126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96127       };
96128     }
96129   }
96130
96131 }
96132
96133
96134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
96135   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96136   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96137
96138   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96139   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96140   {
96141     try {
96142       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
96143     } catch (std::out_of_range& e) {
96144       {
96145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96146       };
96147     } catch (std::exception& e) {
96148       {
96149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96150       };
96151     } catch (Dali::DaliException e) {
96152       {
96153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96154       };
96155     } catch (...) {
96156       {
96157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96158       };
96159     }
96160   }
96161
96162 }
96163
96164
96165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96166   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96167   Dali::Toolkit::PageTurnView arg2 ;
96168   Dali::Toolkit::PageTurnView *argp2 ;
96169
96170   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96171   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96172   if (!argp2) {
96173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96174     return ;
96175   }
96176   arg2 = *argp2;
96177   {
96178     try {
96179       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96180     } catch (std::out_of_range& e) {
96181       {
96182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96183       };
96184     } catch (std::exception& e) {
96185       {
96186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96187       };
96188     } catch (Dali::DaliException e) {
96189       {
96190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96191       };
96192     } catch (...) {
96193       {
96194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96195       };
96196     }
96197   }
96198
96199 }
96200
96201
96202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96203   void * jresult ;
96204   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96205
96206   {
96207     try {
96208       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96209     } catch (std::out_of_range& e) {
96210       {
96211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96212       };
96213     } catch (std::exception& e) {
96214       {
96215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96216       };
96217     } catch (Dali::DaliException e) {
96218       {
96219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96220       };
96221     } catch (...) {
96222       {
96223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96224       };
96225     }
96226   }
96227
96228   jresult = (void *)result;
96229   return jresult;
96230 }
96231
96232
96233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
96234   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96235
96236   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96237   {
96238     try {
96239       delete arg1;
96240     } catch (std::out_of_range& e) {
96241       {
96242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96243       };
96244     } catch (std::exception& e) {
96245       {
96246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96247       };
96248     } catch (Dali::DaliException e) {
96249       {
96250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96251       };
96252     } catch (...) {
96253       {
96254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96255       };
96256     }
96257   }
96258
96259 }
96260
96261
96262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
96263   unsigned int jresult ;
96264   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96265   bool result;
96266
96267   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96268   {
96269     try {
96270       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);
96271     } catch (std::out_of_range& e) {
96272       {
96273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96274       };
96275     } catch (std::exception& e) {
96276       {
96277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96278       };
96279     } catch (Dali::DaliException e) {
96280       {
96281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96282       };
96283     } catch (...) {
96284       {
96285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96286       };
96287     }
96288   }
96289
96290   jresult = result;
96291   return jresult;
96292 }
96293
96294
96295 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
96296   unsigned long jresult ;
96297   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96298   std::size_t result;
96299
96300   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96301   {
96302     try {
96303       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);
96304     } catch (std::out_of_range& e) {
96305       {
96306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96307       };
96308     } catch (std::exception& e) {
96309       {
96310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96311       };
96312     } catch (Dali::DaliException e) {
96313       {
96314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96315       };
96316     } catch (...) {
96317       {
96318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96319       };
96320     }
96321   }
96322
96323   jresult = (unsigned long)result;
96324   return jresult;
96325 }
96326
96327
96328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
96329   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96330   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96331
96332   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96333   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96334   {
96335     try {
96336       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
96337     } catch (std::out_of_range& e) {
96338       {
96339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96340       };
96341     } catch (std::exception& e) {
96342       {
96343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96344       };
96345     } catch (Dali::DaliException e) {
96346       {
96347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96348       };
96349     } catch (...) {
96350       {
96351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96352       };
96353     }
96354   }
96355
96356 }
96357
96358
96359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96360   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96361   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96362
96363   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96364   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96365   {
96366     try {
96367       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
96368     } catch (std::out_of_range& e) {
96369       {
96370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96371       };
96372     } catch (std::exception& e) {
96373       {
96374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96375       };
96376     } catch (Dali::DaliException e) {
96377       {
96378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96379       };
96380     } catch (...) {
96381       {
96382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96383       };
96384     }
96385   }
96386
96387 }
96388
96389
96390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
96391   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96392   Dali::Toolkit::ProgressBar arg2 ;
96393   float arg3 ;
96394   float arg4 ;
96395   Dali::Toolkit::ProgressBar *argp2 ;
96396
96397   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96398   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
96399   if (!argp2) {
96400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
96401     return ;
96402   }
96403   arg2 = *argp2;
96404   arg3 = (float)jarg3;
96405   arg4 = (float)jarg4;
96406   {
96407     try {
96408       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96409     } catch (std::out_of_range& e) {
96410       {
96411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96412       };
96413     } catch (std::exception& e) {
96414       {
96415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96416       };
96417     } catch (Dali::DaliException e) {
96418       {
96419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96420       };
96421     } catch (...) {
96422       {
96423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96424       };
96425     }
96426   }
96427
96428 }
96429
96430
96431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
96432   void * jresult ;
96433   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
96434
96435   {
96436     try {
96437       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
96438     } catch (std::out_of_range& e) {
96439       {
96440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96441       };
96442     } catch (std::exception& e) {
96443       {
96444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96445       };
96446     } catch (Dali::DaliException e) {
96447       {
96448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96449       };
96450     } catch (...) {
96451       {
96452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96453       };
96454     }
96455   }
96456
96457   jresult = (void *)result;
96458   return jresult;
96459 }
96460
96461
96462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
96463   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96464
96465   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96466   {
96467     try {
96468       delete arg1;
96469     } catch (std::out_of_range& e) {
96470       {
96471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96472       };
96473     } catch (std::exception& e) {
96474       {
96475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96476       };
96477     } catch (Dali::DaliException e) {
96478       {
96479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96480       };
96481     } catch (...) {
96482       {
96483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96484       };
96485     }
96486   }
96487
96488 }
96489
96490
96491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
96492   unsigned int jresult ;
96493   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96494   bool result;
96495
96496   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96497   {
96498     try {
96499       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);
96500     } catch (std::out_of_range& e) {
96501       {
96502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96503       };
96504     } catch (std::exception& e) {
96505       {
96506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96507       };
96508     } catch (Dali::DaliException e) {
96509       {
96510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96511       };
96512     } catch (...) {
96513       {
96514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96515       };
96516     }
96517   }
96518
96519   jresult = result;
96520   return jresult;
96521 }
96522
96523
96524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
96525   unsigned long jresult ;
96526   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96527   std::size_t result;
96528
96529   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96530   {
96531     try {
96532       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);
96533     } catch (std::out_of_range& e) {
96534       {
96535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96536       };
96537     } catch (std::exception& e) {
96538       {
96539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96540       };
96541     } catch (Dali::DaliException e) {
96542       {
96543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96544       };
96545     } catch (...) {
96546       {
96547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96548       };
96549     }
96550   }
96551
96552   jresult = (unsigned long)result;
96553   return jresult;
96554 }
96555
96556
96557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
96558   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96559   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96560
96561   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96562   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96563   {
96564     try {
96565       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96566     } catch (std::out_of_range& e) {
96567       {
96568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96569       };
96570     } catch (std::exception& e) {
96571       {
96572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96573       };
96574     } catch (Dali::DaliException e) {
96575       {
96576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96577       };
96578     } catch (...) {
96579       {
96580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96581       };
96582     }
96583   }
96584
96585 }
96586
96587
96588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
96589   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96590   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96591
96592   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96593   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96594   {
96595     try {
96596       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96597     } catch (std::out_of_range& e) {
96598       {
96599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96600       };
96601     } catch (std::exception& e) {
96602       {
96603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96604       };
96605     } catch (Dali::DaliException e) {
96606       {
96607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96608       };
96609     } catch (...) {
96610       {
96611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96612       };
96613     }
96614   }
96615
96616 }
96617
96618
96619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
96620   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96621   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
96622
96623   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96624   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
96625   if (!arg2) {
96626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
96627     return ;
96628   }
96629   {
96630     try {
96631       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
96632     } catch (std::out_of_range& e) {
96633       {
96634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96635       };
96636     } catch (std::exception& e) {
96637       {
96638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96639       };
96640     } catch (Dali::DaliException e) {
96641       {
96642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96643       };
96644     } catch (...) {
96645       {
96646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96647       };
96648     }
96649   }
96650
96651 }
96652
96653
96654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
96655   void * jresult ;
96656   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
96657
96658   {
96659     try {
96660       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
96661     } catch (std::out_of_range& e) {
96662       {
96663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96664       };
96665     } catch (std::exception& e) {
96666       {
96667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96668       };
96669     } catch (Dali::DaliException e) {
96670       {
96671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96672       };
96673     } catch (...) {
96674       {
96675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96676       };
96677     }
96678   }
96679
96680   jresult = (void *)result;
96681   return jresult;
96682 }
96683
96684
96685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
96686   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96687
96688   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96689   {
96690     try {
96691       delete arg1;
96692     } catch (std::out_of_range& e) {
96693       {
96694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96695       };
96696     } catch (std::exception& e) {
96697       {
96698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96699       };
96700     } catch (Dali::DaliException e) {
96701       {
96702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96703       };
96704     } catch (...) {
96705       {
96706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96707       };
96708     }
96709   }
96710
96711 }
96712
96713
96714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
96715   unsigned int jresult ;
96716   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96717   bool result;
96718
96719   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96720   {
96721     try {
96722       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96723     } catch (std::out_of_range& e) {
96724       {
96725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96726       };
96727     } catch (std::exception& e) {
96728       {
96729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96730       };
96731     } catch (Dali::DaliException e) {
96732       {
96733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96734       };
96735     } catch (...) {
96736       {
96737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96738       };
96739     }
96740   }
96741
96742   jresult = result;
96743   return jresult;
96744 }
96745
96746
96747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
96748   unsigned long jresult ;
96749   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96750   std::size_t result;
96751
96752   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96753   {
96754     try {
96755       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96756     } catch (std::out_of_range& e) {
96757       {
96758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96759       };
96760     } catch (std::exception& e) {
96761       {
96762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96763       };
96764     } catch (Dali::DaliException e) {
96765       {
96766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96767       };
96768     } catch (...) {
96769       {
96770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96771       };
96772     }
96773   }
96774
96775   jresult = (unsigned long)result;
96776   return jresult;
96777 }
96778
96779
96780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
96781   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96782   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96783
96784   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96785   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96786   {
96787     try {
96788       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96789     } catch (std::out_of_range& e) {
96790       {
96791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96792       };
96793     } catch (std::exception& e) {
96794       {
96795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96796       };
96797     } catch (Dali::DaliException e) {
96798       {
96799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96800       };
96801     } catch (...) {
96802       {
96803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96804       };
96805     }
96806   }
96807
96808 }
96809
96810
96811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
96812   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96813   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96814
96815   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96816   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96817   {
96818     try {
96819       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96820     } catch (std::out_of_range& e) {
96821       {
96822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96823       };
96824     } catch (std::exception& e) {
96825       {
96826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96827       };
96828     } catch (Dali::DaliException e) {
96829       {
96830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96831       };
96832     } catch (...) {
96833       {
96834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96835       };
96836     }
96837   }
96838
96839 }
96840
96841
96842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
96843   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96844   Dali::Vector2 *arg2 = 0 ;
96845
96846   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96847   arg2 = (Dali::Vector2 *)jarg2;
96848   if (!arg2) {
96849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
96850     return ;
96851   }
96852   {
96853     try {
96854       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
96855     } catch (std::out_of_range& e) {
96856       {
96857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96858       };
96859     } catch (std::exception& e) {
96860       {
96861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96862       };
96863     } catch (Dali::DaliException e) {
96864       {
96865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96866       };
96867     } catch (...) {
96868       {
96869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96870       };
96871     }
96872   }
96873
96874 }
96875
96876
96877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
96878   void * jresult ;
96879   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
96880
96881   {
96882     try {
96883       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
96884     } catch (std::out_of_range& e) {
96885       {
96886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96887       };
96888     } catch (std::exception& e) {
96889       {
96890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96891       };
96892     } catch (Dali::DaliException e) {
96893       {
96894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96895       };
96896     } catch (...) {
96897       {
96898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96899       };
96900     }
96901   }
96902
96903   jresult = (void *)result;
96904   return jresult;
96905 }
96906
96907
96908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
96909   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96910
96911   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96912   {
96913     try {
96914       delete arg1;
96915     } catch (std::out_of_range& e) {
96916       {
96917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96918       };
96919     } catch (std::exception& e) {
96920       {
96921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96922       };
96923     } catch (Dali::DaliException e) {
96924       {
96925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96926       };
96927     } catch (...) {
96928       {
96929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96930       };
96931     }
96932   }
96933
96934 }
96935
96936
96937
96938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
96939   unsigned int jresult ;
96940   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96941   bool result;
96942
96943   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96944   {
96945     try {
96946       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);
96947     } catch (std::out_of_range& e) {
96948       {
96949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96950       };
96951     } catch (std::exception& e) {
96952       {
96953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96954       };
96955     } catch (Dali::DaliException e) {
96956       {
96957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96958       };
96959     } catch (...) {
96960       {
96961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96962       };
96963     }
96964   }
96965
96966   jresult = result;
96967   return jresult;
96968 }
96969
96970
96971 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
96972   unsigned long jresult ;
96973   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96974   std::size_t result;
96975
96976   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96977   {
96978     try {
96979       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);
96980     } catch (std::out_of_range& e) {
96981       {
96982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96983       };
96984     } catch (std::exception& e) {
96985       {
96986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96987       };
96988     } catch (Dali::DaliException e) {
96989       {
96990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96991       };
96992     } catch (...) {
96993       {
96994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96995       };
96996     }
96997   }
96998
96999   jresult = (unsigned long)result;
97000   return jresult;
97001 }
97002
97003
97004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97005   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97006   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97007
97008   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97009   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97010   {
97011     try {
97012       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97013     } catch (std::out_of_range& e) {
97014       {
97015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97016       };
97017     } catch (std::exception& e) {
97018       {
97019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97020       };
97021     } catch (Dali::DaliException e) {
97022       {
97023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97024       };
97025     } catch (...) {
97026       {
97027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97028       };
97029     }
97030   }
97031
97032 }
97033
97034
97035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
97036   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97037   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97038
97039   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97040   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97041   {
97042     try {
97043       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97044     } catch (std::out_of_range& e) {
97045       {
97046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97047       };
97048     } catch (std::exception& e) {
97049       {
97050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97051       };
97052     } catch (Dali::DaliException e) {
97053       {
97054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97055       };
97056     } catch (...) {
97057       {
97058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97059       };
97060     }
97061   }
97062
97063 }
97064
97065
97066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
97067   unsigned int jresult ;
97068   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97069   Dali::Toolkit::Control arg2 ;
97070   Dali::KeyEvent *arg3 = 0 ;
97071   Dali::Toolkit::Control *argp2 ;
97072   bool result;
97073
97074   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97075   argp2 = (Dali::Toolkit::Control *)jarg2;
97076   if (!argp2) {
97077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97078     return 0;
97079   }
97080   arg2 = *argp2;
97081   arg3 = (Dali::KeyEvent *)jarg3;
97082   if (!arg3) {
97083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
97084     return 0;
97085   }
97086   {
97087     try {
97088       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);
97089     } catch (std::out_of_range& e) {
97090       {
97091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97092       };
97093     } catch (std::exception& e) {
97094       {
97095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97096       };
97097     } catch (Dali::DaliException e) {
97098       {
97099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97100       };
97101     } catch (...) {
97102       {
97103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97104       };
97105     }
97106   }
97107
97108   jresult = result;
97109   return jresult;
97110 }
97111
97112
97113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
97114   void * jresult ;
97115   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
97116
97117   {
97118     try {
97119       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
97120     } catch (std::out_of_range& e) {
97121       {
97122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97123       };
97124     } catch (std::exception& e) {
97125       {
97126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97127       };
97128     } catch (Dali::DaliException e) {
97129       {
97130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97131       };
97132     } catch (...) {
97133       {
97134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97135       };
97136     }
97137   }
97138
97139   jresult = (void *)result;
97140   return jresult;
97141 }
97142
97143
97144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
97145   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97146
97147   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97148   {
97149     try {
97150       delete arg1;
97151     } catch (std::out_of_range& e) {
97152       {
97153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97154       };
97155     } catch (std::exception& e) {
97156       {
97157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97158       };
97159     } catch (Dali::DaliException e) {
97160       {
97161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97162       };
97163     } catch (...) {
97164       {
97165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97166       };
97167     }
97168   }
97169
97170 }
97171
97172
97173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97174   unsigned int jresult ;
97175   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97176   bool result;
97177
97178   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97179   {
97180     try {
97181       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97182     } catch (std::out_of_range& e) {
97183       {
97184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97185       };
97186     } catch (std::exception& e) {
97187       {
97188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97189       };
97190     } catch (Dali::DaliException e) {
97191       {
97192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97193       };
97194     } catch (...) {
97195       {
97196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97197       };
97198     }
97199   }
97200
97201   jresult = result;
97202   return jresult;
97203 }
97204
97205
97206 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97207   unsigned long jresult ;
97208   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97209   std::size_t result;
97210
97211   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97212   {
97213     try {
97214       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97215     } catch (std::out_of_range& e) {
97216       {
97217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97218       };
97219     } catch (std::exception& e) {
97220       {
97221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97222       };
97223     } catch (Dali::DaliException e) {
97224       {
97225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97226       };
97227     } catch (...) {
97228       {
97229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97230       };
97231     }
97232   }
97233
97234   jresult = (unsigned long)result;
97235   return jresult;
97236 }
97237
97238
97239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
97240   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97241   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97242
97243   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97244   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97245   {
97246     try {
97247       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
97248     } catch (std::out_of_range& e) {
97249       {
97250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97251       };
97252     } catch (std::exception& e) {
97253       {
97254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97255       };
97256     } catch (Dali::DaliException e) {
97257       {
97258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97259       };
97260     } catch (...) {
97261       {
97262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97263       };
97264     }
97265   }
97266
97267 }
97268
97269
97270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
97271   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97272   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97273
97274   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97275   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97276   {
97277     try {
97278       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
97279     } catch (std::out_of_range& e) {
97280       {
97281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97282       };
97283     } catch (std::exception& e) {
97284       {
97285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97286       };
97287     } catch (Dali::DaliException e) {
97288       {
97289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97290       };
97291     } catch (...) {
97292       {
97293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97294       };
97295     }
97296   }
97297
97298 }
97299
97300
97301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
97302   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97303   Dali::Toolkit::Control arg2 ;
97304   Dali::Toolkit::Control *argp2 ;
97305
97306   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97307   argp2 = (Dali::Toolkit::Control *)jarg2;
97308   if (!argp2) {
97309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97310     return ;
97311   }
97312   arg2 = *argp2;
97313   {
97314     try {
97315       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
97316     } catch (std::out_of_range& e) {
97317       {
97318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97319       };
97320     } catch (std::exception& e) {
97321       {
97322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97323       };
97324     } catch (Dali::DaliException e) {
97325       {
97326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97327       };
97328     } catch (...) {
97329       {
97330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97331       };
97332     }
97333   }
97334
97335 }
97336
97337
97338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
97339   void * jresult ;
97340   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
97341
97342   {
97343     try {
97344       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
97345     } catch (std::out_of_range& e) {
97346       {
97347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97348       };
97349     } catch (std::exception& e) {
97350       {
97351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97352       };
97353     } catch (Dali::DaliException e) {
97354       {
97355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97356       };
97357     } catch (...) {
97358       {
97359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97360       };
97361     }
97362   }
97363
97364   jresult = (void *)result;
97365   return jresult;
97366 }
97367
97368
97369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
97370   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97371
97372   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97373   {
97374     try {
97375       delete arg1;
97376     } catch (std::out_of_range& e) {
97377       {
97378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97379       };
97380     } catch (std::exception& e) {
97381       {
97382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97383       };
97384     } catch (Dali::DaliException e) {
97385       {
97386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97387       };
97388     } catch (...) {
97389       {
97390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97391       };
97392     }
97393   }
97394
97395 }
97396
97397
97398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
97399   unsigned int jresult ;
97400   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97401   bool result;
97402
97403   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97404   {
97405     try {
97406       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97407     } catch (std::out_of_range& e) {
97408       {
97409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97410       };
97411     } catch (std::exception& e) {
97412       {
97413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97414       };
97415     } catch (Dali::DaliException e) {
97416       {
97417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97418       };
97419     } catch (...) {
97420       {
97421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97422       };
97423     }
97424   }
97425
97426   jresult = result;
97427   return jresult;
97428 }
97429
97430
97431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
97432   unsigned long jresult ;
97433   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97434   std::size_t result;
97435
97436   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97437   {
97438     try {
97439       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97440     } catch (std::out_of_range& e) {
97441       {
97442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97443       };
97444     } catch (std::exception& e) {
97445       {
97446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97447       };
97448     } catch (Dali::DaliException e) {
97449       {
97450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97451       };
97452     } catch (...) {
97453       {
97454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97455       };
97456     }
97457   }
97458
97459   jresult = (unsigned long)result;
97460   return jresult;
97461 }
97462
97463
97464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
97465   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97466   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97467
97468   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97469   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97470   {
97471     try {
97472       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
97473     } catch (std::out_of_range& e) {
97474       {
97475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97476       };
97477     } catch (std::exception& e) {
97478       {
97479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97480       };
97481     } catch (Dali::DaliException e) {
97482       {
97483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97484       };
97485     } catch (...) {
97486       {
97487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97488       };
97489     }
97490   }
97491
97492 }
97493
97494
97495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
97496   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97497   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97498
97499   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97500   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97501   {
97502     try {
97503       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
97504     } catch (std::out_of_range& e) {
97505       {
97506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97507       };
97508     } catch (std::exception& e) {
97509       {
97510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97511       };
97512     } catch (Dali::DaliException e) {
97513       {
97514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97515       };
97516     } catch (...) {
97517       {
97518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97519       };
97520     }
97521   }
97522
97523 }
97524
97525
97526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
97527   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97528   Dali::Toolkit::VideoView *arg2 = 0 ;
97529
97530   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97531   arg2 = (Dali::Toolkit::VideoView *)jarg2;
97532   if (!arg2) {
97533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
97534     return ;
97535   }
97536   {
97537     try {
97538       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
97539     } catch (std::out_of_range& e) {
97540       {
97541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97542       };
97543     } catch (std::exception& e) {
97544       {
97545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97546       };
97547     } catch (Dali::DaliException e) {
97548       {
97549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97550       };
97551     } catch (...) {
97552       {
97553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97554       };
97555     }
97556   }
97557
97558 }
97559
97560
97561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
97562   void * jresult ;
97563   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
97564
97565   {
97566     try {
97567       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
97568     } catch (std::out_of_range& e) {
97569       {
97570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97571       };
97572     } catch (std::exception& e) {
97573       {
97574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97575       };
97576     } catch (Dali::DaliException e) {
97577       {
97578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97579       };
97580     } catch (...) {
97581       {
97582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97583       };
97584     }
97585   }
97586
97587   jresult = (void *)result;
97588   return jresult;
97589 }
97590
97591
97592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
97593   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97594
97595   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97596   {
97597     try {
97598       delete arg1;
97599     } catch (std::out_of_range& e) {
97600       {
97601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97602       };
97603     } catch (std::exception& e) {
97604       {
97605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97606       };
97607     } catch (Dali::DaliException e) {
97608       {
97609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97610       };
97611     } catch (...) {
97612       {
97613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97614       };
97615     }
97616   }
97617
97618 }
97619
97620
97621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
97622   unsigned int jresult ;
97623   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97624   bool result;
97625
97626   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97627   {
97628     try {
97629       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97630     } catch (std::out_of_range& e) {
97631       {
97632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97633       };
97634     } catch (std::exception& e) {
97635       {
97636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97637       };
97638     } catch (Dali::DaliException e) {
97639       {
97640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97641       };
97642     } catch (...) {
97643       {
97644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97645       };
97646     }
97647   }
97648
97649   jresult = result;
97650   return jresult;
97651 }
97652
97653
97654 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
97655   unsigned long jresult ;
97656   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97657   std::size_t result;
97658
97659   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97660   {
97661     try {
97662       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97663     } catch (std::out_of_range& e) {
97664       {
97665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97666       };
97667     } catch (std::exception& e) {
97668       {
97669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97670       };
97671     } catch (Dali::DaliException e) {
97672       {
97673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97674       };
97675     } catch (...) {
97676       {
97677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97678       };
97679     }
97680   }
97681
97682   jresult = (unsigned long)result;
97683   return jresult;
97684 }
97685
97686
97687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97688   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97689   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97690
97691   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97692   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97693   {
97694     try {
97695       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
97696     } catch (std::out_of_range& e) {
97697       {
97698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97699       };
97700     } catch (std::exception& e) {
97701       {
97702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97703       };
97704     } catch (Dali::DaliException e) {
97705       {
97706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97707       };
97708     } catch (...) {
97709       {
97710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97711       };
97712     }
97713   }
97714
97715 }
97716
97717
97718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97719   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97720   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97721
97722   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97723   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97724   {
97725     try {
97726       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97727     } catch (std::out_of_range& e) {
97728       {
97729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97730       };
97731     } catch (std::exception& e) {
97732       {
97733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97734       };
97735     } catch (Dali::DaliException e) {
97736       {
97737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97738       };
97739     } catch (...) {
97740       {
97741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97742       };
97743     }
97744   }
97745
97746 }
97747
97748
97749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
97750   unsigned int jresult ;
97751   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97752   Dali::Toolkit::Slider arg2 ;
97753   float arg3 ;
97754   Dali::Toolkit::Slider *argp2 ;
97755   bool result;
97756
97757   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97758   argp2 = (Dali::Toolkit::Slider *)jarg2;
97759   if (!argp2) {
97760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97761     return 0;
97762   }
97763   arg2 = *argp2;
97764   arg3 = (float)jarg3;
97765   {
97766     try {
97767       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
97768     } catch (std::out_of_range& e) {
97769       {
97770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97771       };
97772     } catch (std::exception& e) {
97773       {
97774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97775       };
97776     } catch (Dali::DaliException e) {
97777       {
97778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97779       };
97780     } catch (...) {
97781       {
97782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97783       };
97784     }
97785   }
97786
97787   jresult = result;
97788   return jresult;
97789 }
97790
97791
97792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
97793   void * jresult ;
97794   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
97795
97796   {
97797     try {
97798       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
97799     } catch (std::out_of_range& e) {
97800       {
97801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97802       };
97803     } catch (std::exception& e) {
97804       {
97805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97806       };
97807     } catch (Dali::DaliException e) {
97808       {
97809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97810       };
97811     } catch (...) {
97812       {
97813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97814       };
97815     }
97816   }
97817
97818   jresult = (void *)result;
97819   return jresult;
97820 }
97821
97822
97823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
97824   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97825
97826   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97827   {
97828     try {
97829       delete arg1;
97830     } catch (std::out_of_range& e) {
97831       {
97832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97833       };
97834     } catch (std::exception& e) {
97835       {
97836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97837       };
97838     } catch (Dali::DaliException e) {
97839       {
97840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97841       };
97842     } catch (...) {
97843       {
97844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97845       };
97846     }
97847   }
97848
97849 }
97850
97851
97852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
97853   unsigned int jresult ;
97854   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97855   bool result;
97856
97857   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97858   {
97859     try {
97860       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97861     } catch (std::out_of_range& e) {
97862       {
97863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97864       };
97865     } catch (std::exception& e) {
97866       {
97867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97868       };
97869     } catch (Dali::DaliException e) {
97870       {
97871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97872       };
97873     } catch (...) {
97874       {
97875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97876       };
97877     }
97878   }
97879
97880   jresult = result;
97881   return jresult;
97882 }
97883
97884
97885 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
97886   unsigned long jresult ;
97887   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97888   std::size_t result;
97889
97890   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97891   {
97892     try {
97893       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97894     } catch (std::out_of_range& e) {
97895       {
97896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97897       };
97898     } catch (std::exception& e) {
97899       {
97900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97901       };
97902     } catch (Dali::DaliException e) {
97903       {
97904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97905       };
97906     } catch (...) {
97907       {
97908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97909       };
97910     }
97911   }
97912
97913   jresult = (unsigned long)result;
97914   return jresult;
97915 }
97916
97917
97918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
97919   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97920   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97921
97922   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97923   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97924   {
97925     try {
97926       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
97927     } catch (std::out_of_range& e) {
97928       {
97929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97930       };
97931     } catch (std::exception& e) {
97932       {
97933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97934       };
97935     } catch (Dali::DaliException e) {
97936       {
97937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97938       };
97939     } catch (...) {
97940       {
97941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97942       };
97943     }
97944   }
97945
97946 }
97947
97948
97949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
97950   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97951   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97952
97953   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97954   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97955   {
97956     try {
97957       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
97958     } catch (std::out_of_range& e) {
97959       {
97960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97961       };
97962     } catch (std::exception& e) {
97963       {
97964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97965       };
97966     } catch (Dali::DaliException e) {
97967       {
97968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97969       };
97970     } catch (...) {
97971       {
97972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97973       };
97974     }
97975   }
97976
97977 }
97978
97979
97980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
97981   unsigned int jresult ;
97982   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97983   Dali::Toolkit::Slider arg2 ;
97984   int arg3 ;
97985   Dali::Toolkit::Slider *argp2 ;
97986   bool result;
97987
97988   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97989   argp2 = (Dali::Toolkit::Slider *)jarg2;
97990   if (!argp2) {
97991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97992     return 0;
97993   }
97994   arg2 = *argp2;
97995   arg3 = (int)jarg3;
97996   {
97997     try {
97998       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
97999     } catch (std::out_of_range& e) {
98000       {
98001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98002       };
98003     } catch (std::exception& e) {
98004       {
98005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98006       };
98007     } catch (Dali::DaliException e) {
98008       {
98009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98010       };
98011     } catch (...) {
98012       {
98013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98014       };
98015     }
98016   }
98017
98018   jresult = result;
98019   return jresult;
98020 }
98021
98022
98023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
98024   void * jresult ;
98025   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
98026
98027   {
98028     try {
98029       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
98030     } catch (std::out_of_range& e) {
98031       {
98032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98033       };
98034     } catch (std::exception& e) {
98035       {
98036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98037       };
98038     } catch (Dali::DaliException e) {
98039       {
98040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98041       };
98042     } catch (...) {
98043       {
98044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98045       };
98046     }
98047   }
98048
98049   jresult = (void *)result;
98050   return jresult;
98051 }
98052
98053
98054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
98055   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98056
98057   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98058   {
98059     try {
98060       delete arg1;
98061     } catch (std::out_of_range& e) {
98062       {
98063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98064       };
98065     } catch (std::exception& e) {
98066       {
98067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98068       };
98069     } catch (Dali::DaliException e) {
98070       {
98071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98072       };
98073     } catch (...) {
98074       {
98075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98076       };
98077     }
98078   }
98079
98080 }
98081
98082
98083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
98084   void * jresult ;
98085   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98086
98087   {
98088     try {
98089       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
98090     } catch (std::out_of_range& e) {
98091       {
98092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98093       };
98094     } catch (std::exception& e) {
98095       {
98096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98097       };
98098     } catch (Dali::DaliException e) {
98099       {
98100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98101       };
98102     } catch (...) {
98103       {
98104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98105       };
98106     }
98107   }
98108
98109   jresult = (void *)result;
98110   return jresult;
98111 }
98112
98113
98114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
98115   void * jresult ;
98116   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
98117   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98118
98119   arg1 = (Dali::Toolkit::Ruler *)jarg1;
98120   {
98121     try {
98122       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
98123     } catch (std::out_of_range& e) {
98124       {
98125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98126       };
98127     } catch (std::exception& e) {
98128       {
98129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98130       };
98131     } catch (Dali::DaliException e) {
98132       {
98133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98134       };
98135     } catch (...) {
98136       {
98137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98138       };
98139     }
98140   }
98141
98142   jresult = (void *)result;
98143   return jresult;
98144 }
98145
98146
98147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
98148   void * jresult ;
98149   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
98150   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98151
98152   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98153   if (!arg1) {
98154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98155     return 0;
98156   }
98157   {
98158     try {
98159       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98160     } catch (std::out_of_range& e) {
98161       {
98162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98163       };
98164     } catch (std::exception& e) {
98165       {
98166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98167       };
98168     } catch (Dali::DaliException e) {
98169       {
98170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98171       };
98172     } catch (...) {
98173       {
98174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98175       };
98176     }
98177   }
98178
98179   jresult = (void *)result;
98180   return jresult;
98181 }
98182
98183
98184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98185   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98186
98187   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98188   {
98189     try {
98190       delete arg1;
98191     } catch (std::out_of_range& e) {
98192       {
98193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98194       };
98195     } catch (std::exception& e) {
98196       {
98197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98198       };
98199     } catch (Dali::DaliException e) {
98200       {
98201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98202       };
98203     } catch (...) {
98204       {
98205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98206       };
98207     }
98208   }
98209
98210 }
98211
98212
98213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98214   void * jresult ;
98215   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98216   Dali::Toolkit::Ruler *result = 0 ;
98217
98218   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98219   {
98220     try {
98221       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
98222     } catch (std::out_of_range& e) {
98223       {
98224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98225       };
98226     } catch (std::exception& e) {
98227       {
98228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98229       };
98230     } catch (Dali::DaliException e) {
98231       {
98232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98233       };
98234     } catch (...) {
98235       {
98236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98237       };
98238     }
98239   }
98240
98241   jresult = (void *)result;
98242   return jresult;
98243 }
98244
98245
98246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
98247   void * jresult ;
98248   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98249   Dali::Toolkit::Ruler *result = 0 ;
98250
98251   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98252   {
98253     try {
98254       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
98255     } catch (std::out_of_range& e) {
98256       {
98257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98258       };
98259     } catch (std::exception& e) {
98260       {
98261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98262       };
98263     } catch (Dali::DaliException e) {
98264       {
98265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98266       };
98267     } catch (...) {
98268       {
98269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98270       };
98271     }
98272   }
98273
98274   jresult = (void *)result;
98275   return jresult;
98276 }
98277
98278
98279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
98280   void * jresult ;
98281   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98282   Dali::Toolkit::Ruler *result = 0 ;
98283
98284   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98285   {
98286     try {
98287       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
98288     } catch (std::out_of_range& e) {
98289       {
98290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98291       };
98292     } catch (std::exception& e) {
98293       {
98294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98295       };
98296     } catch (Dali::DaliException e) {
98297       {
98298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98299       };
98300     } catch (...) {
98301       {
98302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98303       };
98304     }
98305   }
98306
98307   jresult = (void *)result;
98308   return jresult;
98309 }
98310
98311
98312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
98313   void * jresult ;
98314   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98315   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
98316   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98317
98318   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98319   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
98320   if (!arg2) {
98321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98322     return 0;
98323   }
98324   {
98325     try {
98326       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
98327     } catch (std::out_of_range& e) {
98328       {
98329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98330       };
98331     } catch (std::exception& e) {
98332       {
98333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98334       };
98335     } catch (Dali::DaliException e) {
98336       {
98337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98338       };
98339     } catch (...) {
98340       {
98341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98342       };
98343     }
98344   }
98345
98346   jresult = (void *)result;
98347   return jresult;
98348 }
98349
98350
98351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
98352   void * jresult ;
98353   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98354   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98355   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98356
98357   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98358   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98359   {
98360     try {
98361       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
98362     } catch (std::out_of_range& e) {
98363       {
98364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98365       };
98366     } catch (std::exception& e) {
98367       {
98368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98369       };
98370     } catch (Dali::DaliException e) {
98371       {
98372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98373       };
98374     } catch (...) {
98375       {
98376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98377       };
98378     }
98379   }
98380
98381   jresult = (void *)result;
98382   return jresult;
98383 }
98384
98385
98386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
98387   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98388
98389   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98390   {
98391     try {
98392       (arg1)->Reset();
98393     } catch (std::out_of_range& e) {
98394       {
98395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98396       };
98397     } catch (std::exception& e) {
98398       {
98399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98400       };
98401     } catch (Dali::DaliException e) {
98402       {
98403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98404       };
98405     } catch (...) {
98406       {
98407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98408       };
98409     }
98410   }
98411
98412 }
98413
98414
98415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
98416   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98417   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98418
98419   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98420   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98421   {
98422     try {
98423       (arg1)->Reset(arg2);
98424     } catch (std::out_of_range& e) {
98425       {
98426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98427       };
98428     } catch (std::exception& e) {
98429       {
98430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98431       };
98432     } catch (Dali::DaliException e) {
98433       {
98434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98435       };
98436     } catch (...) {
98437       {
98438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98439       };
98440     }
98441   }
98442
98443 }
98444
98445
98446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
98447   void * jresult ;
98448   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98449   Dali::Toolkit::Ruler *result = 0 ;
98450
98451   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98452   {
98453     try {
98454       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
98455     } catch (std::out_of_range& e) {
98456       {
98457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98458       };
98459     } catch (std::exception& e) {
98460       {
98461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98462       };
98463     } catch (Dali::DaliException e) {
98464       {
98465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98466       };
98467     } catch (...) {
98468       {
98469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98470       };
98471     }
98472   }
98473
98474   jresult = (void *)result;
98475   return jresult;
98476 }
98477
98478
98479 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
98480   float jresult ;
98481   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98482   float arg2 ;
98483   float arg3 ;
98484   float result;
98485
98486   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98487   arg2 = (float)jarg2;
98488   arg3 = (float)jarg3;
98489   {
98490     try {
98491       result = (float)(*arg1)->Snap(arg2,arg3);
98492     } catch (std::out_of_range& e) {
98493       {
98494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98495       };
98496     } catch (std::exception& e) {
98497       {
98498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98499       };
98500     } catch (Dali::DaliException e) {
98501       {
98502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98503       };
98504     } catch (...) {
98505       {
98506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98507       };
98508     }
98509   }
98510
98511   jresult = result;
98512   return jresult;
98513 }
98514
98515
98516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
98517   float jresult ;
98518   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98519   float arg2 ;
98520   float result;
98521
98522   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98523   arg2 = (float)jarg2;
98524   {
98525     try {
98526       result = (float)(*arg1)->Snap(arg2);
98527     } catch (std::out_of_range& e) {
98528       {
98529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98530       };
98531     } catch (std::exception& e) {
98532       {
98533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98534       };
98535     } catch (Dali::DaliException e) {
98536       {
98537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98538       };
98539     } catch (...) {
98540       {
98541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98542       };
98543     }
98544   }
98545
98546   jresult = result;
98547   return jresult;
98548 }
98549
98550
98551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
98552   float jresult ;
98553   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98554   unsigned int arg2 ;
98555   unsigned int *arg3 = 0 ;
98556   bool arg4 ;
98557   float result;
98558
98559   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98560   arg2 = (unsigned int)jarg2;
98561   arg3 = (unsigned int *)jarg3;
98562   arg4 = jarg4 ? true : false;
98563   {
98564     try {
98565       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
98566     } catch (std::out_of_range& e) {
98567       {
98568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98569       };
98570     } catch (std::exception& e) {
98571       {
98572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98573       };
98574     } catch (Dali::DaliException e) {
98575       {
98576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98577       };
98578     } catch (...) {
98579       {
98580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98581       };
98582     }
98583   }
98584
98585   jresult = result;
98586   return jresult;
98587 }
98588
98589
98590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
98591   unsigned int jresult ;
98592   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98593   float arg2 ;
98594   bool arg3 ;
98595   unsigned int result;
98596
98597   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98598   arg2 = (float)jarg2;
98599   arg3 = jarg3 ? true : false;
98600   {
98601     try {
98602       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
98603     } catch (std::out_of_range& e) {
98604       {
98605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98606       };
98607     } catch (std::exception& e) {
98608       {
98609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98610       };
98611     } catch (Dali::DaliException e) {
98612       {
98613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98614       };
98615     } catch (...) {
98616       {
98617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98618       };
98619     }
98620   }
98621
98622   jresult = result;
98623   return jresult;
98624 }
98625
98626
98627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
98628   unsigned int jresult ;
98629   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98630   unsigned int result;
98631
98632   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98633   {
98634     try {
98635       result = (unsigned int)(*arg1)->GetTotalPages();
98636     } catch (std::out_of_range& e) {
98637       {
98638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98639       };
98640     } catch (std::exception& e) {
98641       {
98642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98643       };
98644     } catch (Dali::DaliException e) {
98645       {
98646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98647       };
98648     } catch (...) {
98649       {
98650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98651       };
98652     }
98653   }
98654
98655   jresult = result;
98656   return jresult;
98657 }
98658
98659
98660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
98661   int jresult ;
98662   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98663   Dali::Toolkit::Ruler::RulerType result;
98664
98665   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98666   {
98667     try {
98668       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
98669     } catch (std::out_of_range& e) {
98670       {
98671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98672       };
98673     } catch (std::exception& e) {
98674       {
98675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98676       };
98677     } catch (Dali::DaliException e) {
98678       {
98679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98680       };
98681     } catch (...) {
98682       {
98683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98684       };
98685     }
98686   }
98687
98688   jresult = (int)result;
98689   return jresult;
98690 }
98691
98692
98693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
98694   unsigned int jresult ;
98695   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98696   bool result;
98697
98698   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98699   {
98700     try {
98701       result = (bool)(*arg1)->IsEnabled();
98702     } catch (std::out_of_range& e) {
98703       {
98704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98705       };
98706     } catch (std::exception& e) {
98707       {
98708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98709       };
98710     } catch (Dali::DaliException e) {
98711       {
98712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98713       };
98714     } catch (...) {
98715       {
98716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98717       };
98718     }
98719   }
98720
98721   jresult = result;
98722   return jresult;
98723 }
98724
98725
98726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
98727   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98728
98729   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98730   {
98731     try {
98732       (*arg1)->Enable();
98733     } catch (std::out_of_range& e) {
98734       {
98735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98736       };
98737     } catch (std::exception& e) {
98738       {
98739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98740       };
98741     } catch (Dali::DaliException e) {
98742       {
98743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98744       };
98745     } catch (...) {
98746       {
98747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98748       };
98749     }
98750   }
98751
98752 }
98753
98754
98755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
98756   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98757
98758   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98759   {
98760     try {
98761       (*arg1)->Disable();
98762     } catch (std::out_of_range& e) {
98763       {
98764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98765       };
98766     } catch (std::exception& e) {
98767       {
98768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98769       };
98770     } catch (Dali::DaliException e) {
98771       {
98772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98773       };
98774     } catch (...) {
98775       {
98776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98777       };
98778     }
98779   }
98780
98781 }
98782
98783
98784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
98785   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98786   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
98787   Dali::Toolkit::RulerDomain *argp2 ;
98788
98789   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98790   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
98791   if (!argp2) {
98792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
98793     return ;
98794   }
98795   arg2 = *argp2;
98796   {
98797     try {
98798       (*arg1)->SetDomain(arg2);
98799     } catch (std::out_of_range& e) {
98800       {
98801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98802       };
98803     } catch (std::exception& e) {
98804       {
98805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98806       };
98807     } catch (Dali::DaliException e) {
98808       {
98809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98810       };
98811     } catch (...) {
98812       {
98813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98814       };
98815     }
98816   }
98817
98818 }
98819
98820
98821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
98822   void * jresult ;
98823   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98824   Dali::Toolkit::RulerDomain *result = 0 ;
98825
98826   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98827   {
98828     try {
98829       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
98830     } catch (std::out_of_range& e) {
98831       {
98832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98833       };
98834     } catch (std::exception& e) {
98835       {
98836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98837       };
98838     } catch (Dali::DaliException e) {
98839       {
98840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98841       };
98842     } catch (...) {
98843       {
98844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98845       };
98846     }
98847   }
98848
98849   jresult = (void *)result;
98850   return jresult;
98851 }
98852
98853
98854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
98855   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98856
98857   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98858   {
98859     try {
98860       (*arg1)->DisableDomain();
98861     } catch (std::out_of_range& e) {
98862       {
98863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98864       };
98865     } catch (std::exception& e) {
98866       {
98867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98868       };
98869     } catch (Dali::DaliException e) {
98870       {
98871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98872       };
98873     } catch (...) {
98874       {
98875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98876       };
98877     }
98878   }
98879
98880 }
98881
98882
98883 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
98884   float jresult ;
98885   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98886   float arg2 ;
98887   float arg3 ;
98888   float arg4 ;
98889   float result;
98890
98891   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98892   arg2 = (float)jarg2;
98893   arg3 = (float)jarg3;
98894   arg4 = (float)jarg4;
98895   {
98896     try {
98897       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
98898     } catch (std::out_of_range& e) {
98899       {
98900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98901       };
98902     } catch (std::exception& e) {
98903       {
98904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98905       };
98906     } catch (Dali::DaliException e) {
98907       {
98908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98909       };
98910     } catch (...) {
98911       {
98912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98913       };
98914     }
98915   }
98916
98917   jresult = result;
98918   return jresult;
98919 }
98920
98921
98922 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
98923   float jresult ;
98924   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98925   float arg2 ;
98926   float arg3 ;
98927   float result;
98928
98929   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98930   arg2 = (float)jarg2;
98931   arg3 = (float)jarg3;
98932   {
98933     try {
98934       result = (float)(*arg1)->Clamp(arg2,arg3);
98935     } catch (std::out_of_range& e) {
98936       {
98937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98938       };
98939     } catch (std::exception& e) {
98940       {
98941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98942       };
98943     } catch (Dali::DaliException e) {
98944       {
98945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98946       };
98947     } catch (...) {
98948       {
98949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98950       };
98951     }
98952   }
98953
98954   jresult = result;
98955   return jresult;
98956 }
98957
98958
98959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
98960   float jresult ;
98961   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98962   float arg2 ;
98963   float result;
98964
98965   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98966   arg2 = (float)jarg2;
98967   {
98968     try {
98969       result = (float)(*arg1)->Clamp(arg2);
98970     } catch (std::out_of_range& e) {
98971       {
98972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98973       };
98974     } catch (std::exception& e) {
98975       {
98976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98977       };
98978     } catch (Dali::DaliException e) {
98979       {
98980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98981       };
98982     } catch (...) {
98983       {
98984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98985       };
98986     }
98987   }
98988
98989   jresult = result;
98990   return jresult;
98991 }
98992
98993
98994 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
98995   float jresult ;
98996   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98997   float arg2 ;
98998   float arg3 ;
98999   float arg4 ;
99000   Dali::Toolkit::ClampState *arg5 = 0 ;
99001   float result;
99002
99003   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99004   arg2 = (float)jarg2;
99005   arg3 = (float)jarg3;
99006   arg4 = (float)jarg4;
99007   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99008   if (!arg5) {
99009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99010     return 0;
99011   }
99012   {
99013     try {
99014       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
99015     } catch (std::out_of_range& e) {
99016       {
99017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99018       };
99019     } catch (std::exception& e) {
99020       {
99021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99022       };
99023     } catch (Dali::DaliException e) {
99024       {
99025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99026       };
99027     } catch (...) {
99028       {
99029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99030       };
99031     }
99032   }
99033
99034   jresult = result;
99035   return jresult;
99036 }
99037
99038
99039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
99040   float jresult ;
99041   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99042   float arg2 ;
99043   float arg3 ;
99044   float arg4 ;
99045   float arg5 ;
99046   float result;
99047
99048   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99049   arg2 = (float)jarg2;
99050   arg3 = (float)jarg3;
99051   arg4 = (float)jarg4;
99052   arg5 = (float)jarg5;
99053   {
99054     try {
99055       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
99056     } catch (std::out_of_range& e) {
99057       {
99058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99059       };
99060     } catch (std::exception& e) {
99061       {
99062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99063       };
99064     } catch (Dali::DaliException e) {
99065       {
99066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99067       };
99068     } catch (...) {
99069       {
99070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99071       };
99072     }
99073   }
99074
99075   jresult = result;
99076   return jresult;
99077 }
99078
99079
99080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
99081   float jresult ;
99082   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99083   float arg2 ;
99084   float arg3 ;
99085   float arg4 ;
99086   float result;
99087
99088   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99089   arg2 = (float)jarg2;
99090   arg3 = (float)jarg3;
99091   arg4 = (float)jarg4;
99092   {
99093     try {
99094       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
99095     } catch (std::out_of_range& e) {
99096       {
99097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99098       };
99099     } catch (std::exception& e) {
99100       {
99101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99102       };
99103     } catch (Dali::DaliException e) {
99104       {
99105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99106       };
99107     } catch (...) {
99108       {
99109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99110       };
99111     }
99112   }
99113
99114   jresult = result;
99115   return jresult;
99116 }
99117
99118
99119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
99120   float jresult ;
99121   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99122   float arg2 ;
99123   float arg3 ;
99124   float result;
99125
99126   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99127   arg2 = (float)jarg2;
99128   arg3 = (float)jarg3;
99129   {
99130     try {
99131       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
99132     } catch (std::out_of_range& e) {
99133       {
99134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99135       };
99136     } catch (std::exception& e) {
99137       {
99138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99139       };
99140     } catch (Dali::DaliException e) {
99141       {
99142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99143       };
99144     } catch (...) {
99145       {
99146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99147       };
99148     }
99149   }
99150
99151   jresult = result;
99152   return jresult;
99153 }
99154
99155
99156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99157   float jresult ;
99158   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99159   float arg2 ;
99160   float result;
99161
99162   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99163   arg2 = (float)jarg2;
99164   {
99165     try {
99166       result = (float)(*arg1)->SnapAndClamp(arg2);
99167     } catch (std::out_of_range& e) {
99168       {
99169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99170       };
99171     } catch (std::exception& e) {
99172       {
99173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99174       };
99175     } catch (Dali::DaliException e) {
99176       {
99177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99178       };
99179     } catch (...) {
99180       {
99181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99182       };
99183     }
99184   }
99185
99186   jresult = result;
99187   return jresult;
99188 }
99189
99190
99191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99192   float jresult ;
99193   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99194   float arg2 ;
99195   float arg3 ;
99196   float arg4 ;
99197   float arg5 ;
99198   Dali::Toolkit::ClampState *arg6 = 0 ;
99199   float result;
99200
99201   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99202   arg2 = (float)jarg2;
99203   arg3 = (float)jarg3;
99204   arg4 = (float)jarg4;
99205   arg5 = (float)jarg5;
99206   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99207   if (!arg6) {
99208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99209     return 0;
99210   }
99211   {
99212     try {
99213       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99214     } catch (std::out_of_range& e) {
99215       {
99216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99217       };
99218     } catch (std::exception& e) {
99219       {
99220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99221       };
99222     } catch (Dali::DaliException e) {
99223       {
99224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99225       };
99226     } catch (...) {
99227       {
99228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99229       };
99230     }
99231   }
99232
99233   jresult = result;
99234   return jresult;
99235 }
99236
99237
99238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
99239   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99240
99241   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99242   {
99243     try {
99244       (*arg1)->Reference();
99245     } catch (std::out_of_range& e) {
99246       {
99247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99248       };
99249     } catch (std::exception& e) {
99250       {
99251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99252       };
99253     } catch (Dali::DaliException e) {
99254       {
99255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99256       };
99257     } catch (...) {
99258       {
99259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99260       };
99261     }
99262   }
99263
99264 }
99265
99266
99267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
99268   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99269
99270   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99271   {
99272     try {
99273       (*arg1)->Unreference();
99274     } catch (std::out_of_range& e) {
99275       {
99276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99277       };
99278     } catch (std::exception& e) {
99279       {
99280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99281       };
99282     } catch (Dali::DaliException e) {
99283       {
99284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99285       };
99286     } catch (...) {
99287       {
99288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99289       };
99290     }
99291   }
99292
99293 }
99294
99295
99296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
99297   int jresult ;
99298   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99299   int result;
99300
99301   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99302   {
99303     try {
99304       result = (int)(*arg1)->ReferenceCount();
99305     } catch (std::out_of_range& e) {
99306       {
99307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99308       };
99309     } catch (std::exception& e) {
99310       {
99311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99312       };
99313     } catch (Dali::DaliException e) {
99314       {
99315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99316       };
99317     } catch (...) {
99318       {
99319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99320       };
99321     }
99322   }
99323
99324   jresult = result;
99325   return jresult;
99326 }
99327
99328
99329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
99330   unsigned int jresult ;
99331   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99332   bool result;
99333
99334   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99335   {
99336     try {
99337       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99338     } catch (std::out_of_range& e) {
99339       {
99340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99341       };
99342     } catch (std::exception& e) {
99343       {
99344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99345       };
99346     } catch (Dali::DaliException e) {
99347       {
99348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99349       };
99350     } catch (...) {
99351       {
99352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99353       };
99354     }
99355   }
99356
99357   jresult = result;
99358   return jresult;
99359 }
99360
99361
99362 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
99363   unsigned long jresult ;
99364   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99365   std::size_t result;
99366
99367   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99368   {
99369     try {
99370       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99371     } catch (std::out_of_range& e) {
99372       {
99373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99374       };
99375     } catch (std::exception& e) {
99376       {
99377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99378       };
99379     } catch (Dali::DaliException e) {
99380       {
99381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99382       };
99383     } catch (...) {
99384       {
99385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99386       };
99387     }
99388   }
99389
99390   jresult = (unsigned long)result;
99391   return jresult;
99392 }
99393
99394
99395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
99396   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99397   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99398
99399   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99400   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99401   {
99402     try {
99403       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
99404     } catch (std::out_of_range& e) {
99405       {
99406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99407       };
99408     } catch (std::exception& e) {
99409       {
99410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99411       };
99412     } catch (Dali::DaliException e) {
99413       {
99414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99415       };
99416     } catch (...) {
99417       {
99418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99419       };
99420     }
99421   }
99422
99423 }
99424
99425
99426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
99427   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99428   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99429
99430   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99431   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99432   {
99433     try {
99434       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
99435     } catch (std::out_of_range& e) {
99436       {
99437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99438       };
99439     } catch (std::exception& e) {
99440       {
99441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99442       };
99443     } catch (Dali::DaliException e) {
99444       {
99445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99446       };
99447     } catch (...) {
99448       {
99449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99450       };
99451     }
99452   }
99453
99454 }
99455
99456
99457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
99458   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99459   Dali::Toolkit::Control arg2 ;
99460   Dali::Toolkit::Control *argp2 ;
99461
99462   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99463   argp2 = (Dali::Toolkit::Control *)jarg2;
99464   if (!argp2) {
99465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
99466     return ;
99467   }
99468   arg2 = *argp2;
99469   {
99470     try {
99471       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
99472     } catch (std::out_of_range& e) {
99473       {
99474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99475       };
99476     } catch (std::exception& e) {
99477       {
99478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99479       };
99480     } catch (Dali::DaliException e) {
99481       {
99482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99483       };
99484     } catch (...) {
99485       {
99486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99487       };
99488     }
99489   }
99490
99491 }
99492
99493
99494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
99495   void * jresult ;
99496   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
99497
99498   {
99499     try {
99500       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
99501     } catch (std::out_of_range& e) {
99502       {
99503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99504       };
99505     } catch (std::exception& e) {
99506       {
99507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99508       };
99509     } catch (Dali::DaliException e) {
99510       {
99511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99512       };
99513     } catch (...) {
99514       {
99515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99516       };
99517     }
99518   }
99519
99520   jresult = (void *)result;
99521   return jresult;
99522 }
99523
99524
99525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
99526   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99527
99528   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99529   {
99530     try {
99531       delete arg1;
99532     } catch (std::out_of_range& e) {
99533       {
99534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99535       };
99536     } catch (std::exception& e) {
99537       {
99538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99539       };
99540     } catch (Dali::DaliException e) {
99541       {
99542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99543       };
99544     } catch (...) {
99545       {
99546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99547       };
99548     }
99549   }
99550
99551 }
99552
99553 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
99554   Dali::RefObject *result = NULL;
99555
99556   if (arg1)
99557   {
99558     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
99559   }
99560   return result;
99561 }
99562
99563 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
99564     return (Dali::RefObject *)jarg1;
99565 }
99566
99567 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
99568     return (Dali::SignalObserver *)jarg1;
99569 }
99570
99571 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
99572     return (Dali::ConnectionTrackerInterface *)jarg1;
99573 }
99574
99575 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
99576     return (Dali::BaseHandle *)jarg1;
99577 }
99578
99579 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
99580     return (Dali::BaseHandle *)jarg1;
99581 }
99582
99583 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
99584     return (Dali::BaseHandle *)jarg1;
99585 }
99586
99587 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
99588     return (Dali::BaseHandle *)jarg1;
99589 }
99590
99591 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
99592     return (Dali::BaseHandle *)jarg1;
99593 }
99594
99595 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
99596     return (Dali::BaseHandle *)jarg1;
99597 }
99598
99599 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
99600     return (Dali::BaseHandle *)jarg1;
99601 }
99602
99603 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
99604     return (Dali::BaseHandle *)jarg1;
99605 }
99606
99607 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
99608     return (Dali::BaseHandle *)jarg1;
99609 }
99610
99611 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
99612     return (Dali::BaseHandle *)jarg1;
99613 }
99614
99615 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
99616     return (Dali::BaseHandle *)jarg1;
99617 }
99618
99619 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
99620     return (Dali::BaseHandle *)jarg1;
99621 }
99622
99623 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
99624     return (Dali::BaseHandle *)jarg1;
99625 }
99626
99627 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
99628     return (Dali::Handle *)jarg1;
99629 }
99630
99631 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
99632     return (Dali::Handle *)jarg1;
99633 }
99634
99635 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
99636     return (Dali::BaseHandle *)jarg1;
99637 }
99638
99639 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
99640     return (Dali::BaseHandle *)jarg1;
99641 }
99642
99643 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
99644     return (Dali::Handle *)jarg1;
99645 }
99646
99647 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
99648     return (Dali::BaseHandle *)jarg1;
99649 }
99650
99651 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
99652     return (Dali::Handle *)jarg1;
99653 }
99654
99655 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
99656     return (Dali::GestureDetector *)jarg1;
99657 }
99658
99659 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
99660     return (Dali::Gesture *)jarg1;
99661 }
99662
99663 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
99664     return (Dali::Handle *)jarg1;
99665 }
99666
99667 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
99668     return (Dali::Actor *)jarg1;
99669 }
99670
99671 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
99672     return (Dali::BaseHandle *)jarg1;
99673 }
99674
99675 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
99676     return (Dali::RefObject *)jarg1;
99677 }
99678
99679 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
99680     return (Dali::Actor *)jarg1;
99681 }
99682
99683 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
99684     return (Dali::GestureDetector *)jarg1;
99685 }
99686
99687 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
99688     return (Dali::Gesture *)jarg1;
99689 }
99690
99691 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
99692     return (Dali::GestureDetector *)jarg1;
99693 }
99694
99695 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
99696     return (Dali::Gesture *)jarg1;
99697 }
99698
99699 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
99700     return (Dali::GestureDetector *)jarg1;
99701 }
99702
99703 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
99704     return (Dali::Gesture *)jarg1;
99705 }
99706
99707 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
99708     return (Dali::BaseHandle *)jarg1;
99709 }
99710
99711 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
99712     return (Dali::Handle *)jarg1;
99713 }
99714
99715 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
99716     return (Dali::Handle *)jarg1;
99717 }
99718
99719 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
99720     return (Dali::Handle *)jarg1;
99721 }
99722
99723 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
99724     return (Dali::Image *)jarg1;
99725 }
99726
99727 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
99728     return (Dali::Image *)jarg1;
99729 }
99730
99731 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
99732     return (Dali::Image *)jarg1;
99733 }
99734
99735 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
99736     return (Dali::RefObject *)jarg1;
99737 }
99738
99739 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
99740     return (Dali::Image *)jarg1;
99741 }
99742
99743 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
99744     return (Dali::Image *)jarg1;
99745 }
99746
99747 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
99748     return (Dali::ResourceImage *)jarg1;
99749 }
99750
99751 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
99752     return (Dali::Actor *)jarg1;
99753 }
99754
99755 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
99756     return (Dali::BaseHandle *)jarg1;
99757 }
99758
99759 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
99760     return (Dali::BaseHandle *)jarg1;
99761 }
99762
99763 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
99764     return (Dali::BaseHandle *)jarg1;
99765 }
99766
99767 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
99768     return (Dali::CustomActorImpl *)jarg1;
99769 }
99770
99771 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
99772     return (Dali::CustomActor *)jarg1;
99773 }
99774
99775 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
99776     return (Dali::BaseHandle *)jarg1;
99777 }
99778
99779 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
99780     return (Dali::Toolkit::Control *)jarg1;
99781 }
99782
99783 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
99784     return (Dali::Toolkit::Control *)jarg1;
99785 }
99786
99787 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
99788     return (Dali::Toolkit::Button *)jarg1;
99789 }
99790
99791 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
99792     return (Dali::Toolkit::Button *)jarg1;
99793 }
99794
99795 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
99796     return (Dali::Toolkit::Button *)jarg1;
99797 }
99798
99799 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
99800     return (Dali::Toolkit::Control *)jarg1;
99801 }
99802
99803 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
99804     return (Dali::Toolkit::Control *)jarg1;
99805 }
99806
99807 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
99808     return (Dali::Toolkit::Control *)jarg1;
99809 }
99810
99811 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
99812     return (Dali::Toolkit::Control *)jarg1;
99813 }
99814
99815 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
99816     return (Dali::Toolkit::Control *)jarg1;
99817 }
99818
99819 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
99820     return (Dali::RefObject *)jarg1;
99821 }
99822
99823 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
99824     return (Dali::Toolkit::Scrollable *)jarg1;
99825 }
99826
99827 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
99828     return (Dali::BaseHandle *)jarg1;
99829 }
99830
99831 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
99832     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
99833 }
99834
99835 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
99836     return (Dali::RefObject *)jarg1;
99837 }
99838
99839 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
99840     return (Dali::Toolkit::Ruler *)jarg1;
99841 }
99842
99843 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
99844     return (Dali::Toolkit::Ruler *)jarg1;
99845 }
99846
99847 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
99848     return (Dali::Toolkit::Scrollable *)jarg1;
99849 }
99850
99851 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
99852     return (Dali::Toolkit::Control *)jarg1;
99853 }
99854
99855
99856 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
99857     return (Dali::Toolkit::Control *)jarg1;
99858 }
99859
99860 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
99861     return (Dali::BaseHandle *)jarg1;
99862 }
99863
99864 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
99865     return (Dali::BaseHandle *)jarg1;
99866 }
99867
99868 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
99869     return (Dali::Toolkit::Control *)jarg1;
99870 }
99871
99872 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
99873     return (Dali::Toolkit::Control *)jarg1;
99874 }
99875
99876 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
99877     return (Dali::Toolkit::Control *)jarg1;
99878 }
99879
99880 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
99881     return (Dali::Toolkit::Control *)jarg1;
99882 }
99883
99884 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
99885     return (Dali::Toolkit::Control *)jarg1;
99886 }
99887
99888 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
99889     return (Dali::Toolkit::Control *)jarg1;
99890 }
99891
99892 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
99893     return (Dali::Toolkit::PageTurnView *)jarg1;
99894 }
99895
99896 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
99897     return (Dali::Toolkit::PageTurnView *)jarg1;
99898 }
99899
99900 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
99901     return (Dali::Toolkit::Button *)jarg1;
99902 }
99903
99904 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
99905     return (Dali::BaseHandle *)jarg1;
99906 }
99907
99908 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
99909     return (Dali::BaseHandle *)jarg1;
99910 }
99911
99912 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
99913     return (Dali::BaseHandle *)jarg1;
99914 }
99915
99916 /*
99917  * Widget binding
99918  */
99919 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
99920     return (Dali::BaseHandle *)jarg1;
99921 }
99922
99923 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
99924     return (Dali::BaseObject *)jarg1;
99925 }
99926
99927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
99928   void * jresult ;
99929   Dali::Widget result;
99930
99931   {
99932     try {
99933       result = Dali::Widget::New();
99934     } catch (std::out_of_range& e) {
99935       {
99936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99937       };
99938     } catch (std::exception& e) {
99939       {
99940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99941       };
99942     } catch (...) {
99943       {
99944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99945       };
99946     }
99947   }
99948   jresult = new Dali::Widget((const Dali::Widget &)result);
99949   return jresult;
99950 }
99951
99952
99953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
99954   void * jresult ;
99955   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
99956   Dali::Widget result;
99957
99958   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99959
99960   if (!arg1) {
99961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
99962     return 0;
99963   }
99964   {
99965     try {
99966       jresult = new Dali::Widget(arg1);
99967     } catch (std::out_of_range& e) {
99968       {
99969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99970       };
99971     } catch (std::exception& e) {
99972       {
99973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99974       };
99975     } catch (...) {
99976       {
99977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99978       };
99979     }
99980   }
99981   return jresult;
99982 }
99983
99984
99985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
99986   void * jresult ;
99987   Dali::Widget *result = 0 ;
99988
99989   {
99990     try {
99991       result = (Dali::Widget *)new Dali::Widget();
99992     } catch (std::out_of_range& e) {
99993       {
99994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99995       };
99996     } catch (std::exception& e) {
99997       {
99998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99999       };
100000     } catch (...) {
100001       {
100002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100003       };
100004     }
100005   }
100006   jresult = (void *)result;
100007   return jresult;
100008 }
100009
100010
100011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
100012   void * jresult ;
100013   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100014   Dali::Widget *arg2 = 0 ;
100015   Dali::Widget *result = 0 ;
100016
100017   arg1 = (Dali::Widget *)jarg1;
100018   arg2 = (Dali::Widget *)jarg2;
100019   if (!arg2) {
100020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
100021     return 0;
100022   }
100023   {
100024     try {
100025       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
100026     } catch (std::out_of_range& e) {
100027       {
100028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100029       };
100030     } catch (std::exception& e) {
100031       {
100032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100033       };
100034     } catch (...) {
100035       {
100036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100037       };
100038     }
100039   }
100040   jresult = (void *)result;
100041   return jresult;
100042 }
100043
100044
100045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
100046   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100047
100048   arg1 = (Dali::Widget *)jarg1;
100049   {
100050     try {
100051       delete arg1;
100052     } catch (std::out_of_range& e) {
100053       {
100054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100055       };
100056     } catch (std::exception& e) {
100057       {
100058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100059       };
100060     } catch (...) {
100061       {
100062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100063       };
100064     }
100065   }
100066 }
100067
100068
100069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
100070   void * jresult ;
100071   SwigDirector_WidgetImpl* result;
100072   {
100073     try {
100074       result = new SwigDirector_WidgetImpl();
100075     } catch (std::out_of_range& e) {
100076       {
100077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100078       };
100079     } catch (std::exception& e) {
100080       {
100081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100082       };
100083     } catch (...) {
100084       {
100085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100086       };
100087     }
100088   }
100089   jresult = result;
100090   return jresult;
100091 }
100092
100093
100094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
100095   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100096   std::string *arg2 = 0 ;
100097   Dali::Window arg3 ;
100098   Dali::Window *argp3 ;
100099
100100   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100101   if (!jarg2) {
100102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100103     return ;
100104   }
100105   std::string arg2_str(jarg2);
100106   arg2 = &arg2_str;
100107   argp3 = (Dali::Window *)jarg3;
100108   if (!argp3) {
100109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100110     return ;
100111   }
100112   arg3 = *argp3;
100113   {
100114     try {
100115       (arg1)->OnCreate((std::string const &)*arg2,arg3);
100116     } catch (std::out_of_range& e) {
100117       {
100118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100119       };
100120     } catch (std::exception& e) {
100121       {
100122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100123       };
100124     } catch (...) {
100125       {
100126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100127       };
100128     }
100129   }
100130 }
100131
100132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
100133   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100134   std::string *arg2 = 0 ;
100135   Dali::Window arg3 ;
100136   Dali::Window *argp3 ;
100137
100138   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100139   if (!jarg2) {
100140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100141     return ;
100142   }
100143   std::string arg2_str(jarg2);
100144   arg2 = &arg2_str;
100145   argp3 = (Dali::Window *)jarg3;
100146   if (!argp3) {
100147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100148     return ;
100149   }
100150   arg3 = *argp3;
100151   {
100152     try {
100153       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100154     } catch (std::out_of_range& e) {
100155       {
100156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100157       };
100158     } catch (std::exception& e) {
100159       {
100160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100161       };
100162     } catch (...) {
100163       {
100164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100165       };
100166     }
100167   }
100168 }
100169
100170
100171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100172   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100173   std::string *arg2 = 0 ;
100174   Dali::Widget::Termination arg3 ;
100175
100176   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100177   if (!jarg2) {
100178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100179     return ;
100180   }
100181   std::string arg2_str(jarg2);
100182   arg2 = &arg2_str;
100183   arg3 = (Dali::Widget::Termination)jarg3;
100184   {
100185     try {
100186       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100187     } catch (std::out_of_range& e) {
100188       {
100189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100190       };
100191     } catch (std::exception& e) {
100192       {
100193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100194       };
100195     } catch (...) {
100196       {
100197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100198       };
100199     }
100200   }
100201 }
100202
100203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100204   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100205   std::string *arg2 = 0 ;
100206   Dali::Widget::Termination arg3 ;
100207
100208   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100209   if (!jarg2) {
100210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100211     return ;
100212   }
100213   std::string arg2_str(jarg2);
100214   arg2 = &arg2_str;
100215   arg3 = (Dali::Widget::Termination)jarg3;
100216   {
100217     try {
100218       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
100219     } catch (std::out_of_range& e) {
100220       {
100221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100222       };
100223     } catch (std::exception& e) {
100224       {
100225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100226       };
100227     } catch (...) {
100228       {
100229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100230       };
100231     }
100232   }
100233 }
100234
100235
100236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
100237   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100238
100239   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100240   {
100241     try {
100242       (arg1)->OnPause();
100243     } catch (std::out_of_range& e) {
100244       {
100245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100246       };
100247     } catch (std::exception& e) {
100248       {
100249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100250       };
100251     } catch (...) {
100252       {
100253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100254       };
100255     }
100256   }
100257 }
100258
100259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
100260   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100261
100262   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100263   {
100264     try {
100265       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
100266     } catch (std::out_of_range& e) {
100267       {
100268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100269       };
100270     } catch (std::exception& e) {
100271       {
100272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100273       };
100274     } catch (...) {
100275       {
100276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100277       };
100278     }
100279   }
100280 }
100281
100282
100283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
100284   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100285
100286   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100287   {
100288     try {
100289       (arg1)->OnResume();
100290     } catch (std::out_of_range& e) {
100291       {
100292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100293       };
100294     } catch (std::exception& e) {
100295       {
100296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100297       };
100298     } catch (...) {
100299       {
100300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100301       };
100302     }
100303   }
100304 }
100305
100306
100307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
100308   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100309
100310   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100311   {
100312     try {
100313       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
100314     } catch (std::out_of_range& e) {
100315       {
100316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100317       };
100318     } catch (std::exception& e) {
100319       {
100320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100321       };
100322     } catch (...) {
100323       {
100324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100325       };
100326     }
100327   }
100328 }
100329
100330
100331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
100332   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100333   Dali::Window arg2 ;
100334   Dali::Window *argp2 ;
100335
100336   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100337   argp2 = (Dali::Window *)jarg2;
100338   if (!argp2) {
100339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100340     return ;
100341   }
100342   arg2 = *argp2;
100343   {
100344     try {
100345       (arg1)->OnResize(arg2);
100346     } catch (std::out_of_range& e) {
100347       {
100348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100349       };
100350     } catch (std::exception& e) {
100351       {
100352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100353       };
100354     } catch (...) {
100355       {
100356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100357       };
100358     }
100359   }
100360 }
100361
100362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
100363   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100364   Dali::Window arg2 ;
100365   Dali::Window *argp2 ;
100366
100367   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100368   argp2 = (Dali::Window *)jarg2;
100369   if (!argp2) {
100370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100371     return ;
100372   }
100373   arg2 = *argp2;
100374   {
100375     try {
100376       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
100377     } catch (std::out_of_range& e) {
100378       {
100379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100380       };
100381     } catch (std::exception& e) {
100382       {
100383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100384       };
100385     } catch (...) {
100386       {
100387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100388       };
100389     }
100390   }
100391 }
100392
100393
100394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
100395   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100396   std::string *arg2 = 0 ;
100397   int arg3 ;
100398
100399   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100400   if (!jarg2) {
100401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100402     return ;
100403   }
100404   std::string arg2_str(jarg2);
100405   arg2 = &arg2_str;
100406   arg3 = (int)jarg3;
100407   {
100408     try {
100409       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
100410     } catch (std::out_of_range& e) {
100411       {
100412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100413       };
100414     } catch (std::exception& e) {
100415       {
100416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100417       };
100418     } catch (...) {
100419       {
100420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100421       };
100422     }
100423   }
100424 }
100425
100426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100427   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100428   std::string *arg2 = 0 ;
100429   int arg3 ;
100430
100431   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100432   if (!jarg2) {
100433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100434     return ;
100435   }
100436   std::string arg2_str(jarg2);
100437   arg2 = &arg2_str;
100438   arg3 = (int)jarg3;
100439   {
100440     try {
100441       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
100442     } catch (std::out_of_range& e) {
100443       {
100444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100445       };
100446     } catch (std::exception& e) {
100447       {
100448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100449       };
100450     } catch (...) {
100451       {
100452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100453       };
100454     }
100455   }
100456 }
100457
100458
100459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
100460   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100461   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100462   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100463
100464   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100465   arg2 = (Dali::SlotObserver *)jarg2;
100466   arg3 = (Dali::CallbackBase *)jarg3;
100467   {
100468     try {
100469       (arg1)->SignalConnected(arg2,arg3);
100470     } catch (std::out_of_range& e) {
100471       {
100472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100473       };
100474     } catch (std::exception& e) {
100475       {
100476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100477       };
100478     } catch (...) {
100479       {
100480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100481       };
100482     }
100483   }
100484 }
100485
100486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100487   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100488   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100489   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100490
100491   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100492   arg2 = (Dali::SlotObserver *)jarg2;
100493   arg3 = (Dali::CallbackBase *)jarg3;
100494   {
100495     try {
100496       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
100497     } catch (std::out_of_range& e) {
100498       {
100499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100500       };
100501     } catch (std::exception& e) {
100502       {
100503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100504       };
100505     } catch (...) {
100506       {
100507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100508       };
100509     }
100510   }
100511 }
100512
100513
100514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
100515   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100516   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100517   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100518
100519   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100520   arg2 = (Dali::SlotObserver *)jarg2;
100521   arg3 = (Dali::CallbackBase *)jarg3;
100522   {
100523     try {
100524       (arg1)->SignalDisconnected(arg2,arg3);
100525     } catch (std::out_of_range& e) {
100526       {
100527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100528       };
100529     } catch (std::exception& e) {
100530       {
100531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100532       };
100533     } catch (...) {
100534       {
100535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100536       };
100537     }
100538   }
100539 }
100540
100541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100542   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100543   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100544   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100545
100546   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100547   arg2 = (Dali::SlotObserver *)jarg2;
100548   arg3 = (Dali::CallbackBase *)jarg3;
100549   {
100550     try {
100551       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
100552     } catch (std::out_of_range& e) {
100553       {
100554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100555       };
100556     } catch (std::exception& e) {
100557       {
100558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100559       };
100560     } catch (...) {
100561       {
100562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100563       };
100564     }
100565   }
100566 }
100567
100568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
100569   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100570   std::string *arg2 = 0 ;
100571
100572   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100573   if (!jarg2) {
100574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100575     return ;
100576   }
100577   std::string arg2_str(jarg2);
100578   arg2 = &arg2_str;
100579   {
100580     try {
100581       (arg1)->SetContentInfo((std::string const &)*arg2);
100582     } catch (std::out_of_range& e) {
100583       {
100584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100585       };
100586     } catch (std::exception& e) {
100587       {
100588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100589       };
100590     } catch (...) {
100591       {
100592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100593       };
100594     }
100595   }
100596 }
100597
100598
100599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
100600   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100601   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
100602
100603   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100604   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
100605   {
100606     try {
100607       (arg1)->SetImpl(arg2);
100608     } catch (std::out_of_range& e) {
100609       {
100610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100611       };
100612     } catch (std::exception& e) {
100613       {
100614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100615       };
100616     } catch (...) {
100617       {
100618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100619       };
100620     }
100621   }
100622 }
100623
100624 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) {
100625
100626   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
100627   if (director) {
100628     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
100629   }
100630 }
100631
100632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
100633   void * jresult ;
100634   Dali::Widget *arg1 = 0 ;
100635   SwigDirector_WidgetImpl *result = 0 ;
100636
100637   arg1 = (Dali::Widget *)jarg1;
100638   if (!arg1) {
100639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
100640     return 0;
100641   }
100642   {
100643     try {
100644       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
100645     } catch (std::out_of_range& e) {
100646       {
100647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100648       };
100649     } catch (std::exception& e) {
100650       {
100651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100652       };
100653     } catch (...) {
100654       {
100655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100656       };
100657     }
100658   }
100659
100660   jresult = (void *)result;
100661   return jresult;
100662 }
100663
100664
100665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
100666   void * jresult ;
100667   int *arg1 = (int *) 0 ;
100668   char ***arg2 ;
100669   std::string *arg3 = 0 ;
100670   Dali::WidgetApplication result;
100671   {
100672     int index = 0;
100673     int length = 0;
100674     char *retPtr;
100675     char *nextPtr;
100676     argWidgetC = jarg1;
100677     argWidgetV = new char*[jarg1 + 1];
100678
100679     retPtr = strtok_r( jarg2, " ", &nextPtr);
100680     if( retPtr )
100681     {
100682       length = strlen(retPtr);
100683     }
100684     argWidgetV[index] = new char[length + 1];
100685     if( retPtr )
100686     {
100687       strncpy(argWidgetV[index], retPtr, length);
100688     }
100689     argWidgetV[index][length] = '\0';
100690     index++;
100691
100692     while (index < jarg1)
100693     {
100694       length = 0;
100695       retPtr = strtok_r(NULL, " ", &nextPtr);
100696       if( retPtr )
100697       {
100698         length = strlen(retPtr);
100699       }
100700       argWidgetV[index] = new char[length + 1];
100701       if( retPtr )
100702       {
100703         strncpy(argWidgetV[index], retPtr, length);
100704       }
100705       argWidgetV[index][length] = '\0';
100706       index++;
100707     }
100708
100709     argWidgetV[jarg1] = NULL;
100710     argWidgetC = jarg1;
100711
100712     arg1 = &argWidgetC;
100713     arg2 = &argWidgetV;
100714   }
100715
100716   if (!jarg3) {
100717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100718     return 0;
100719   }
100720   std::string arg3_str(jarg3);
100721   arg3 = &arg3_str;
100722   {
100723     try {
100724       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
100725     } catch (std::out_of_range& e) {
100726       {
100727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100728       };
100729     } catch (std::exception& e) {
100730       {
100731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100732       };
100733     } catch (...) {
100734       {
100735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100736       };
100737     }
100738   }
100739   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
100740
100741   return jresult;
100742 }
100743
100744
100745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
100746   void * jresult ;
100747   Dali::WidgetApplication *result = 0 ;
100748
100749   {
100750     try {
100751       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
100752     } catch (std::out_of_range& e) {
100753       {
100754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100755       };
100756     } catch (std::exception& e) {
100757       {
100758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100759       };
100760     } catch (...) {
100761       {
100762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100763       };
100764     }
100765   }
100766   jresult = (void *)result;
100767   return jresult;
100768 }
100769
100770
100771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
100772   void * jresult ;
100773   Dali::WidgetApplication *arg1 = 0 ;
100774   Dali::WidgetApplication *result = 0 ;
100775
100776   arg1 = (Dali::WidgetApplication *)jarg1;
100777   if (!arg1) {
100778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100779     return 0;
100780   }
100781   {
100782     try {
100783       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
100784     } catch (std::out_of_range& e) {
100785       {
100786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100787       };
100788     } catch (std::exception& e) {
100789       {
100790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100791       };
100792     } catch (...) {
100793       {
100794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100795       };
100796     }
100797   }
100798   jresult = (void *)result;
100799   return jresult;
100800 }
100801
100802
100803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
100804   void * jresult ;
100805   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100806   Dali::WidgetApplication *arg2 = 0 ;
100807   Dali::WidgetApplication *result = 0 ;
100808
100809   arg1 = (Dali::WidgetApplication *)jarg1;
100810   arg2 = (Dali::WidgetApplication *)jarg2;
100811   if (!arg2) {
100812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100813     return 0;
100814   }
100815   {
100816     try {
100817       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
100818     } catch (std::out_of_range& e) {
100819       {
100820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100821       };
100822     } catch (std::exception& e) {
100823       {
100824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100825       };
100826     } catch (...) {
100827       {
100828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100829       };
100830     }
100831   }
100832   jresult = (void *)result;
100833   return jresult;
100834 }
100835
100836
100837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
100838   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100839
100840   arg1 = (Dali::WidgetApplication *)jarg1;
100841   {
100842     try {
100843       delete arg1;
100844       if( argWidgetV )
100845       {
100846         // free string data
100847         for( int i=0; i < argWidgetC+1; i++)
100848         {
100849           delete [] argWidgetV[i];
100850         }
100851         delete [] argWidgetV;
100852       }
100853     } catch (std::out_of_range& e) {
100854       {
100855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100856       };
100857     } catch (std::exception& e) {
100858       {
100859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100860       };
100861     } catch (...) {
100862       {
100863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100864       };
100865     }
100866   }
100867 }
100868
100869
100870 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
100871 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
100872
100873 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
100874 {
100875   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
100876   return *widget;
100877 }
100878
100879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
100880   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100881   std::string *arg2 = 0 ;
100882
100883   arg1 = (Dali::WidgetApplication *)jarg1;
100884   if (!jarg2) {
100885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100886     return ;
100887   }
100888   std::string arg2_str(*jarg2);
100889   arg2 = &arg2_str;
100890
100891   if(!_CSharpCreateWidgetFunction)
100892   {
100893     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
100894   }
100895
100896   {
100897     try {
100898       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
100899     } catch (std::out_of_range& e) {
100900       {
100901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100902       };
100903     } catch (std::exception& e) {
100904       {
100905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100906       };
100907     } catch (...) {
100908       {
100909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100910       };
100911     }
100912   }
100913
100914   //Typemap argout in c++ file.
100915   //This will convert c++ string to c# string
100916   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
100917 }
100918
100919
100920 //for PixelBuffer and ImageLoading
100921
100922 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
100923     return (Dali::BaseHandle *)jarg1;
100924 }
100925
100926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
100927   void * jresult ;
100928   unsigned int arg1 ;
100929   unsigned int arg2 ;
100930   Dali::Pixel::Format arg3 ;
100931   Dali::Devel::PixelBuffer result;
100932
100933   arg1 = (unsigned int)jarg1;
100934   arg2 = (unsigned int)jarg2;
100935   arg3 = (Dali::Pixel::Format)jarg3;
100936   {
100937     try {
100938       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
100939     } catch (std::out_of_range& e) {
100940       {
100941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100942       };
100943     } catch (std::exception& e) {
100944       {
100945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100946       };
100947     } catch (...) {
100948       {
100949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100950       };
100951     }
100952   }
100953   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100954   return jresult;
100955 }
100956
100957
100958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
100959   void * jresult ;
100960   Dali::Devel::PixelBuffer *result = 0 ;
100961
100962   {
100963     try {
100964       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
100965     } catch (std::out_of_range& e) {
100966       {
100967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100968       };
100969     } catch (std::exception& e) {
100970       {
100971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100972       };
100973     } catch (...) {
100974       {
100975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100976       };
100977     }
100978   }
100979   jresult = (void *)result;
100980   return jresult;
100981 }
100982
100983
100984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
100985   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100986
100987   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100988   {
100989     try {
100990       delete arg1;
100991     } catch (std::out_of_range& e) {
100992       {
100993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100994       };
100995     } catch (std::exception& e) {
100996       {
100997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100998       };
100999     } catch (...) {
101000       {
101001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101002       };
101003     }
101004   }
101005 }
101006
101007
101008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101009   void * jresult ;
101010   Dali::Devel::PixelBuffer *arg1 = 0 ;
101011   Dali::Devel::PixelBuffer *result = 0 ;
101012
101013   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101014   if (!arg1) {
101015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101016     return 0;
101017   }
101018   {
101019     try {
101020       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101021     } catch (std::out_of_range& e) {
101022       {
101023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101024       };
101025     } catch (std::exception& e) {
101026       {
101027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101028       };
101029     } catch (...) {
101030       {
101031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101032       };
101033     }
101034   }
101035   jresult = (void *)result;
101036   return jresult;
101037 }
101038
101039
101040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101041   void * jresult ;
101042   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101043   Dali::Devel::PixelBuffer *arg2 = 0 ;
101044   Dali::Devel::PixelBuffer *result = 0 ;
101045
101046   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101047   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101048   if (!arg2) {
101049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101050     return 0;
101051   }
101052   {
101053     try {
101054       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101055     } catch (std::out_of_range& e) {
101056       {
101057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101058       };
101059     } catch (std::exception& e) {
101060       {
101061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101062       };
101063     } catch (...) {
101064       {
101065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101066       };
101067     }
101068   }
101069   jresult = (void *)result;
101070   return jresult;
101071 }
101072
101073
101074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101075   void * jresult ;
101076   Dali::Devel::PixelBuffer *arg1 = 0 ;
101077   Dali::PixelData result;
101078
101079   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101080   if (!arg1) {
101081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101082     return 0;
101083   }
101084   {
101085     try {
101086       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101087     } catch (std::out_of_range& e) {
101088       {
101089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101090       };
101091     } catch (std::exception& e) {
101092       {
101093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101094       };
101095     } catch (...) {
101096       {
101097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101098       };
101099     }
101100   }
101101   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101102   return jresult;
101103 }
101104
101105
101106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101107   void * jresult ;
101108   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101109   Dali::PixelData result;
101110
101111   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101112   {
101113     try {
101114       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101115     } catch (std::out_of_range& e) {
101116       {
101117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101118       };
101119     } catch (std::exception& e) {
101120       {
101121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101122       };
101123     } catch (...) {
101124       {
101125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101126       };
101127     }
101128   }
101129   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101130   return jresult;
101131 }
101132
101133
101134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101135   void * jresult ;
101136   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101137   unsigned char *result = 0 ;
101138
101139   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101140   {
101141     try {
101142       result = (unsigned char *)(arg1)->GetBuffer();
101143     } catch (std::out_of_range& e) {
101144       {
101145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101146       };
101147     } catch (std::exception& e) {
101148       {
101149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101150       };
101151     } catch (...) {
101152       {
101153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101154       };
101155     }
101156   }
101157   jresult = (void *)result;
101158   return jresult;
101159 }
101160
101161
101162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101163   unsigned int jresult ;
101164   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101165   unsigned int result;
101166
101167   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101168   {
101169     try {
101170       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101171     } catch (std::out_of_range& e) {
101172       {
101173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101174       };
101175     } catch (std::exception& e) {
101176       {
101177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101178       };
101179     } catch (...) {
101180       {
101181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101182       };
101183     }
101184   }
101185   jresult = result;
101186   return jresult;
101187 }
101188
101189
101190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101191   unsigned int jresult ;
101192   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101193   unsigned int result;
101194
101195   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101196   {
101197     try {
101198       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101199     } catch (std::out_of_range& e) {
101200       {
101201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101202       };
101203     } catch (std::exception& e) {
101204       {
101205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101206       };
101207     } catch (...) {
101208       {
101209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101210       };
101211     }
101212   }
101213   jresult = result;
101214   return jresult;
101215 }
101216
101217
101218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101219   int jresult ;
101220   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101221   Dali::Pixel::Format result;
101222
101223   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101224   {
101225     try {
101226       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101227     } catch (std::out_of_range& e) {
101228       {
101229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101230       };
101231     } catch (std::exception& e) {
101232       {
101233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101234       };
101235     } catch (...) {
101236       {
101237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101238       };
101239     }
101240   }
101241   jresult = (int)result;
101242   return jresult;
101243 }
101244
101245
101246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101247   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101248   Dali::Devel::PixelBuffer arg2 ;
101249   float arg3 ;
101250   bool arg4 ;
101251   Dali::Devel::PixelBuffer *argp2 ;
101252
101253   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101254   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101255   if (!argp2) {
101256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101257     return ;
101258   }
101259   arg2 = *argp2;
101260   arg3 = (float)jarg3;
101261   arg4 = jarg4 ? true : false;
101262   {
101263     try {
101264       (arg1)->ApplyMask(arg2,arg3,arg4);
101265     } catch (std::out_of_range& e) {
101266       {
101267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101268       };
101269     } catch (std::exception& e) {
101270       {
101271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101272       };
101273     } catch (...) {
101274       {
101275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101276       };
101277     }
101278   }
101279 }
101280
101281
101282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
101283   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101284   Dali::Devel::PixelBuffer arg2 ;
101285   float arg3 ;
101286   Dali::Devel::PixelBuffer *argp2 ;
101287
101288   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101289   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101290   if (!argp2) {
101291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101292     return ;
101293   }
101294   arg2 = *argp2;
101295   arg3 = (float)jarg3;
101296   {
101297     try {
101298       (arg1)->ApplyMask(arg2,arg3);
101299     } catch (std::out_of_range& e) {
101300       {
101301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101302       };
101303     } catch (std::exception& e) {
101304       {
101305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101306       };
101307     } catch (...) {
101308       {
101309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101310       };
101311     }
101312   }
101313 }
101314
101315
101316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
101317   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101318   Dali::Devel::PixelBuffer arg2 ;
101319   Dali::Devel::PixelBuffer *argp2 ;
101320
101321   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101322   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101323   if (!argp2) {
101324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101325     return ;
101326   }
101327   arg2 = *argp2;
101328   {
101329     try {
101330       (arg1)->ApplyMask(arg2);
101331     } catch (std::out_of_range& e) {
101332       {
101333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101334       };
101335     } catch (std::exception& e) {
101336       {
101337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101338       };
101339     } catch (...) {
101340       {
101341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101342       };
101343     }
101344   }
101345 }
101346
101347
101348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
101349   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101350   float arg2 ;
101351
101352   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101353   arg2 = (float)jarg2;
101354   {
101355     try {
101356       (arg1)->ApplyGaussianBlur(arg2);
101357     } catch (std::out_of_range& e) {
101358       {
101359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101360       };
101361     } catch (std::exception& e) {
101362       {
101363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101364       };
101365     } catch (...) {
101366       {
101367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101368       };
101369     }
101370   }
101371 }
101372
101373
101374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
101375   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101376   uint16_t arg2 ;
101377   uint16_t arg3 ;
101378   uint16_t arg4 ;
101379   uint16_t arg5 ;
101380
101381   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101382   arg2 = (uint16_t)jarg2;
101383   arg3 = (uint16_t)jarg3;
101384   arg4 = (uint16_t)jarg4;
101385   arg5 = (uint16_t)jarg5;
101386   {
101387     try {
101388       (arg1)->Crop(arg2,arg3,arg4,arg5);
101389     } catch (std::out_of_range& e) {
101390       {
101391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101392       };
101393     } catch (std::exception& e) {
101394       {
101395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101396       };
101397     } catch (...) {
101398       {
101399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101400       };
101401     }
101402   }
101403 }
101404
101405
101406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
101407   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101408   uint16_t arg2 ;
101409   uint16_t arg3 ;
101410
101411   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101412   arg2 = (uint16_t)jarg2;
101413   arg3 = (uint16_t)jarg3;
101414   {
101415     try {
101416       (arg1)->Resize(arg2,arg3);
101417     } catch (std::out_of_range& e) {
101418       {
101419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101420       };
101421     } catch (std::exception& e) {
101422       {
101423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101424       };
101425     } catch (...) {
101426       {
101427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101428       };
101429     }
101430   }
101431 }
101432
101433
101434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101435   void * jresult ;
101436   std::string *arg1 = 0 ;
101437   Dali::ImageDimensions arg2 ;
101438   Dali::FittingMode::Type arg3 ;
101439   Dali::SamplingMode::Type arg4 ;
101440   bool arg5 ;
101441   Dali::ImageDimensions *argp2 ;
101442   Dali::Devel::PixelBuffer result;
101443
101444   if (!jarg1) {
101445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101446     return 0;
101447   }
101448   std::string arg1_str(jarg1);
101449   arg1 = &arg1_str;
101450   argp2 = (Dali::ImageDimensions *)jarg2;
101451   if (!argp2) {
101452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101453     return 0;
101454   }
101455   arg2 = *argp2;
101456   arg3 = (Dali::FittingMode::Type)jarg3;
101457   arg4 = (Dali::SamplingMode::Type)jarg4;
101458   arg5 = jarg5 ? true : false;
101459   {
101460     try {
101461       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101462     } catch (std::out_of_range& e) {
101463       {
101464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101465       };
101466     } catch (std::exception& e) {
101467       {
101468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101469       };
101470     } catch (...) {
101471       {
101472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101473       };
101474     }
101475   }
101476   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101477
101478   return jresult;
101479 }
101480
101481
101482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101483   void * jresult ;
101484   std::string *arg1 = 0 ;
101485   Dali::ImageDimensions arg2 ;
101486   Dali::FittingMode::Type arg3 ;
101487   Dali::SamplingMode::Type arg4 ;
101488   Dali::ImageDimensions *argp2 ;
101489   Dali::Devel::PixelBuffer result;
101490
101491   if (!jarg1) {
101492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101493     return 0;
101494   }
101495   std::string arg1_str(jarg1);
101496   arg1 = &arg1_str;
101497   argp2 = (Dali::ImageDimensions *)jarg2;
101498   if (!argp2) {
101499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101500     return 0;
101501   }
101502   arg2 = *argp2;
101503   arg3 = (Dali::FittingMode::Type)jarg3;
101504   arg4 = (Dali::SamplingMode::Type)jarg4;
101505   {
101506     try {
101507       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
101508     } catch (std::out_of_range& e) {
101509       {
101510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101511       };
101512     } catch (std::exception& e) {
101513       {
101514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101515       };
101516     } catch (...) {
101517       {
101518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101519       };
101520     }
101521   }
101522   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101523
101524   return jresult;
101525 }
101526
101527
101528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101529   void * jresult ;
101530   std::string *arg1 = 0 ;
101531   Dali::ImageDimensions arg2 ;
101532   Dali::FittingMode::Type arg3 ;
101533   Dali::ImageDimensions *argp2 ;
101534   Dali::Devel::PixelBuffer result;
101535
101536   if (!jarg1) {
101537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101538     return 0;
101539   }
101540   std::string arg1_str(jarg1);
101541   arg1 = &arg1_str;
101542   argp2 = (Dali::ImageDimensions *)jarg2;
101543   if (!argp2) {
101544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101545     return 0;
101546   }
101547   arg2 = *argp2;
101548   arg3 = (Dali::FittingMode::Type)jarg3;
101549   {
101550     try {
101551       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
101552     } catch (std::out_of_range& e) {
101553       {
101554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101555       };
101556     } catch (std::exception& e) {
101557       {
101558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101559       };
101560     } catch (...) {
101561       {
101562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101563       };
101564     }
101565   }
101566   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101567
101568   return jresult;
101569 }
101570
101571
101572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
101573   void * jresult ;
101574   std::string *arg1 = 0 ;
101575   Dali::ImageDimensions arg2 ;
101576   Dali::ImageDimensions *argp2 ;
101577   Dali::Devel::PixelBuffer result;
101578
101579   if (!jarg1) {
101580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101581     return 0;
101582   }
101583   std::string arg1_str(jarg1);
101584   arg1 = &arg1_str;
101585   argp2 = (Dali::ImageDimensions *)jarg2;
101586   if (!argp2) {
101587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101588     return 0;
101589   }
101590   arg2 = *argp2;
101591   {
101592     try {
101593       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
101594     } catch (std::out_of_range& e) {
101595       {
101596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101597       };
101598     } catch (std::exception& e) {
101599       {
101600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101601       };
101602     } catch (...) {
101603       {
101604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101605       };
101606     }
101607   }
101608   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101609
101610   return jresult;
101611 }
101612
101613
101614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
101615   void * jresult ;
101616   std::string *arg1 = 0 ;
101617   Dali::Devel::PixelBuffer result;
101618
101619   if (!jarg1) {
101620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101621     return 0;
101622   }
101623   std::string arg1_str(jarg1);
101624   arg1 = &arg1_str;
101625   {
101626     try {
101627       result = Dali::LoadImageFromFile((std::string const &)*arg1);
101628     } catch (std::out_of_range& e) {
101629       {
101630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101631       };
101632     } catch (std::exception& e) {
101633       {
101634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101635       };
101636     } catch (...) {
101637       {
101638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101639       };
101640     }
101641   }
101642   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101643
101644   return jresult;
101645 }
101646
101647
101648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101649   void * jresult ;
101650   std::string *arg1 = 0 ;
101651   Dali::ImageDimensions arg2 ;
101652   Dali::FittingMode::Type arg3 ;
101653   Dali::SamplingMode::Type arg4 ;
101654   bool arg5 ;
101655   Dali::ImageDimensions *argp2 ;
101656   Dali::ImageDimensions result;
101657
101658   if (!jarg1) {
101659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101660     return 0;
101661   }
101662   std::string arg1_str(jarg1);
101663   arg1 = &arg1_str;
101664   argp2 = (Dali::ImageDimensions *)jarg2;
101665   if (!argp2) {
101666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101667     return 0;
101668   }
101669   arg2 = *argp2;
101670   arg3 = (Dali::FittingMode::Type)jarg3;
101671   arg4 = (Dali::SamplingMode::Type)jarg4;
101672   arg5 = jarg5 ? true : false;
101673   {
101674     try {
101675       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101676     } catch (std::out_of_range& e) {
101677       {
101678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101679       };
101680     } catch (std::exception& e) {
101681       {
101682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101683       };
101684     } catch (...) {
101685       {
101686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101687       };
101688     }
101689   }
101690   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101691
101692   return jresult;
101693 }
101694
101695
101696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101697   void * jresult ;
101698   std::string *arg1 = 0 ;
101699   Dali::ImageDimensions arg2 ;
101700   Dali::FittingMode::Type arg3 ;
101701   Dali::SamplingMode::Type arg4 ;
101702   Dali::ImageDimensions *argp2 ;
101703   Dali::ImageDimensions result;
101704
101705   if (!jarg1) {
101706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101707     return 0;
101708   }
101709   std::string arg1_str(jarg1);
101710   arg1 = &arg1_str;
101711   argp2 = (Dali::ImageDimensions *)jarg2;
101712   if (!argp2) {
101713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101714     return 0;
101715   }
101716   arg2 = *argp2;
101717   arg3 = (Dali::FittingMode::Type)jarg3;
101718   arg4 = (Dali::SamplingMode::Type)jarg4;
101719   {
101720     try {
101721       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
101722     } catch (std::out_of_range& e) {
101723       {
101724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101725       };
101726     } catch (std::exception& e) {
101727       {
101728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101729       };
101730     } catch (...) {
101731       {
101732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101733       };
101734     }
101735   }
101736   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101737
101738   return jresult;
101739 }
101740
101741
101742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101743   void * jresult ;
101744   std::string *arg1 = 0 ;
101745   Dali::ImageDimensions arg2 ;
101746   Dali::FittingMode::Type arg3 ;
101747   Dali::ImageDimensions *argp2 ;
101748   Dali::ImageDimensions result;
101749
101750   if (!jarg1) {
101751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101752     return 0;
101753   }
101754   std::string arg1_str(jarg1);
101755   arg1 = &arg1_str;
101756   argp2 = (Dali::ImageDimensions *)jarg2;
101757   if (!argp2) {
101758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101759     return 0;
101760   }
101761   arg2 = *argp2;
101762   arg3 = (Dali::FittingMode::Type)jarg3;
101763   {
101764     try {
101765       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
101766     } catch (std::out_of_range& e) {
101767       {
101768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101769       };
101770     } catch (std::exception& e) {
101771       {
101772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101773       };
101774     } catch (...) {
101775       {
101776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101777       };
101778     }
101779   }
101780   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101781
101782   return jresult;
101783 }
101784
101785
101786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
101787   void * jresult ;
101788   std::string *arg1 = 0 ;
101789   Dali::ImageDimensions arg2 ;
101790   Dali::ImageDimensions *argp2 ;
101791   Dali::ImageDimensions result;
101792
101793   if (!jarg1) {
101794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101795     return 0;
101796   }
101797   std::string arg1_str(jarg1);
101798   arg1 = &arg1_str;
101799   argp2 = (Dali::ImageDimensions *)jarg2;
101800   if (!argp2) {
101801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101802     return 0;
101803   }
101804   arg2 = *argp2;
101805   {
101806     try {
101807       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
101808     } catch (std::out_of_range& e) {
101809       {
101810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101811       };
101812     } catch (std::exception& e) {
101813       {
101814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101815       };
101816     } catch (...) {
101817       {
101818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101819       };
101820     }
101821   }
101822   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101823
101824   return jresult;
101825 }
101826
101827
101828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
101829   void * jresult ;
101830   std::string *arg1 = 0 ;
101831   Dali::ImageDimensions result;
101832
101833   if (!jarg1) {
101834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101835     return 0;
101836   }
101837   std::string arg1_str(jarg1);
101838   arg1 = &arg1_str;
101839   {
101840     try {
101841       result = Dali::GetClosestImageSize((std::string const &)*arg1);
101842     } catch (std::out_of_range& e) {
101843       {
101844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101845       };
101846     } catch (std::exception& e) {
101847       {
101848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101849       };
101850     } catch (...) {
101851       {
101852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101853       };
101854     }
101855   }
101856   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101857
101858   return jresult;
101859 }
101860
101861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
101862   void * jresult ;
101863   std::string *arg1 = 0 ;
101864   Dali::ImageDimensions result;
101865
101866   if (!jarg1) {
101867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101868     return 0;
101869   }
101870   std::string arg1_str(jarg1);
101871   arg1 = &arg1_str;
101872   {
101873     try {
101874       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
101875     } catch (std::out_of_range& e) {
101876       {
101877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101878       };
101879     } catch (std::exception& e) {
101880       {
101881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101882       };
101883     } catch (...) {
101884       {
101885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101886       };
101887     }
101888   }
101889   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101890
101891   return jresult;
101892 }
101893
101894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101895   void * jresult ;
101896   std::string *arg1 = 0 ;
101897   Dali::ImageDimensions arg2 ;
101898   Dali::FittingMode::Type arg3 ;
101899   Dali::SamplingMode::Type arg4 ;
101900   bool arg5 ;
101901   Dali::ImageDimensions *argp2 ;
101902   Dali::Devel::PixelBuffer result;
101903
101904   if (!jarg1) {
101905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101906     return 0;
101907   }
101908   std::string arg1_str(jarg1);
101909   arg1 = &arg1_str;
101910   argp2 = (Dali::ImageDimensions *)jarg2;
101911   if (!argp2) {
101912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101913     return 0;
101914   }
101915   arg2 = *argp2;
101916   arg3 = (Dali::FittingMode::Type)jarg3;
101917   arg4 = (Dali::SamplingMode::Type)jarg4;
101918   arg5 = jarg5 ? true : false;
101919   {
101920     try {
101921       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101922     } catch (std::out_of_range& e) {
101923       {
101924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101925       };
101926     } catch (std::exception& e) {
101927       {
101928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101929       };
101930     } catch (...) {
101931       {
101932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101933       };
101934     }
101935   }
101936   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101937
101938   return jresult;
101939 }
101940
101941
101942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101943   void * jresult ;
101944   std::string *arg1 = 0 ;
101945   Dali::ImageDimensions arg2 ;
101946   Dali::FittingMode::Type arg3 ;
101947   Dali::SamplingMode::Type arg4 ;
101948   Dali::ImageDimensions *argp2 ;
101949   Dali::Devel::PixelBuffer result;
101950
101951   if (!jarg1) {
101952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101953     return 0;
101954   }
101955   std::string arg1_str(jarg1);
101956   arg1 = &arg1_str;
101957   argp2 = (Dali::ImageDimensions *)jarg2;
101958   if (!argp2) {
101959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101960     return 0;
101961   }
101962   arg2 = *argp2;
101963   arg3 = (Dali::FittingMode::Type)jarg3;
101964   arg4 = (Dali::SamplingMode::Type)jarg4;
101965   {
101966     try {
101967       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
101968     } catch (std::out_of_range& e) {
101969       {
101970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101971       };
101972     } catch (std::exception& e) {
101973       {
101974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101975       };
101976     } catch (...) {
101977       {
101978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101979       };
101980     }
101981   }
101982   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101983
101984   return jresult;
101985 }
101986
101987
101988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101989   void * jresult ;
101990   std::string *arg1 = 0 ;
101991   Dali::ImageDimensions arg2 ;
101992   Dali::FittingMode::Type arg3 ;
101993   Dali::ImageDimensions *argp2 ;
101994   Dali::Devel::PixelBuffer result;
101995
101996   if (!jarg1) {
101997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101998     return 0;
101999   }
102000   std::string arg1_str(jarg1);
102001   arg1 = &arg1_str;
102002   argp2 = (Dali::ImageDimensions *)jarg2;
102003   if (!argp2) {
102004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102005     return 0;
102006   }
102007   arg2 = *argp2;
102008   arg3 = (Dali::FittingMode::Type)jarg3;
102009   {
102010     try {
102011       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102012     } catch (std::out_of_range& e) {
102013       {
102014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102015       };
102016     } catch (std::exception& e) {
102017       {
102018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102019       };
102020     } catch (...) {
102021       {
102022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102023       };
102024     }
102025   }
102026   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102027
102028   return jresult;
102029 }
102030
102031
102032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102033   void * jresult ;
102034   std::string *arg1 = 0 ;
102035   Dali::ImageDimensions arg2 ;
102036   Dali::ImageDimensions *argp2 ;
102037   Dali::Devel::PixelBuffer result;
102038
102039   if (!jarg1) {
102040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102041     return 0;
102042   }
102043   std::string arg1_str(jarg1);
102044   arg1 = &arg1_str;
102045   argp2 = (Dali::ImageDimensions *)jarg2;
102046   if (!argp2) {
102047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102048     return 0;
102049   }
102050   arg2 = *argp2;
102051   {
102052     try {
102053       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102054     } catch (std::out_of_range& e) {
102055       {
102056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102057       };
102058     } catch (std::exception& e) {
102059       {
102060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102061       };
102062     } catch (...) {
102063       {
102064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102065       };
102066     }
102067   }
102068   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102069
102070   return jresult;
102071 }
102072
102073
102074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102075   void * jresult ;
102076   std::string *arg1 = 0 ;
102077   Dali::Devel::PixelBuffer result;
102078
102079   if (!jarg1) {
102080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102081     return 0;
102082   }
102083   std::string arg1_str(jarg1);
102084   arg1 = &arg1_str;
102085   {
102086     try {
102087       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102088     } catch (std::out_of_range& e) {
102089       {
102090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102091       };
102092     } catch (std::exception& e) {
102093       {
102094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102095       };
102096     } catch (...) {
102097       {
102098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102099       };
102100     }
102101   }
102102   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102103
102104   return jresult;
102105 }
102106
102107
102108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
102109   void * jresult ;
102110   Dali::Toolkit::WebView result;
102111
102112   {
102113     try {
102114       result = Dali::Toolkit::WebView::New();
102115     } catch (std::out_of_range& e) {
102116       {
102117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102118       };
102119     } catch (std::exception& e) {
102120       {
102121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102122       };
102123     } catch (Dali::DaliException e) {
102124       {
102125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102126       };
102127     } catch (...) {
102128       {
102129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102130       };
102131     }
102132   }
102133   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102134   return jresult;
102135 }
102136
102137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
102138   void * jresult ;
102139   Dali::Toolkit::WebView result;
102140
102141   std::string *arg1;
102142   std::string *arg2;
102143
102144   if (!jarg1) {
102145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
102146     return 0;
102147   }
102148   if (!jarg2) {
102149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
102150     return 0;
102151   }
102152
102153   std::string jarg1_str = std::string(jarg1);
102154   std::string jarg2_str = std::string(jarg2);
102155
102156   arg1 = &jarg1_str;
102157   arg2 = &jarg2_str;
102158
102159   {
102160     try {
102161       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102162     } catch (std::out_of_range& e) {
102163       {
102164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102165       };
102166     } catch (std::exception& e) {
102167       {
102168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102169       };
102170     } catch (Dali::DaliException e) {
102171       {
102172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102173       };
102174     } catch (...) {
102175       {
102176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102177       };
102178     }
102179   }
102180   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102181   return jresult;
102182 }
102183
102184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102185   void * jresult ;
102186   Dali::Toolkit::WebView *arg1 = 0 ;
102187   Dali::Toolkit::WebView *result = 0 ;
102188
102189   arg1 = (Dali::Toolkit::WebView *)jarg1;
102190   if (!arg1) {
102191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102192     return 0;
102193   }
102194   {
102195     try {
102196       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102197     } catch (std::out_of_range& e) {
102198       {
102199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102200       };
102201     } catch (std::exception& e) {
102202       {
102203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102204       };
102205     } catch (Dali::DaliException e) {
102206       {
102207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102208       };
102209     } catch (...) {
102210       {
102211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102212       };
102213     }
102214   }
102215   jresult = (void *)result;
102216   return jresult;
102217 }
102218
102219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102220   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102221   arg1 = (Dali::Toolkit::WebView *)jarg1;
102222   {
102223     try {
102224       delete arg1;
102225     } catch (std::out_of_range& e) {
102226       {
102227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102228       };
102229     } catch (std::exception& e) {
102230       {
102231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102232       };
102233     } catch (Dali::DaliException e) {
102234       {
102235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102236       };
102237     } catch (...) {
102238       {
102239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102240       };
102241     }
102242   }
102243 }
102244
102245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
102246   void * jresult ;
102247   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102248   Dali::Toolkit::WebView *arg2 = 0 ;
102249   Dali::Toolkit::WebView *result = 0 ;
102250
102251   arg1 = (Dali::Toolkit::WebView *)jarg1;
102252   arg2 = (Dali::Toolkit::WebView *)jarg2;
102253   if (!arg2) {
102254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102255     return 0;
102256   }
102257   {
102258     try {
102259       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
102260     } catch (std::out_of_range& e) {
102261       {
102262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102263       };
102264     } catch (std::exception& e) {
102265       {
102266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102267       };
102268     } catch (Dali::DaliException e) {
102269       {
102270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102271       };
102272     } catch (...) {
102273       {
102274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102275       };
102276     }
102277   }
102278   jresult = (void *)result;
102279   return jresult;
102280 }
102281
102282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
102283   void * jresult ;
102284   Dali::BaseHandle arg1 ;
102285   Dali::BaseHandle *argp1 ;
102286   Dali::Toolkit::WebView result;
102287
102288   argp1 = (Dali::BaseHandle *)jarg1;
102289   if (!argp1) {
102290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
102291     return 0;
102292   }
102293   arg1 = *argp1;
102294   {
102295     try {
102296       result = Dali::Toolkit::WebView::DownCast(arg1);
102297     } catch (std::out_of_range& e) {
102298       {
102299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102300       };
102301     } catch (std::exception& e) {
102302       {
102303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102304       };
102305     } catch (Dali::DaliException e) {
102306       {
102307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102308       };
102309     } catch (...) {
102310       {
102311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102312       };
102313     }
102314   }
102315   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102316   return jresult;
102317 }
102318
102319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
102320   return (int) Dali::Toolkit::WebView::Property::URL;
102321 }
102322
102323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
102324   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
102325 }
102326
102327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
102328   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
102329 }
102330
102331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
102332   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
102333 }
102334
102335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
102336   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
102337 }
102338
102339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
102340   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
102341 }
102342
102343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
102344   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
102345 }
102346
102347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
102348   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
102349 }
102350
102351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
102352   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102353   std::string *arg2;
102354
102355   arg1 = (Dali::Toolkit::WebView *)jarg1;
102356
102357   if (!jarg2) {
102358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102359     return;
102360   }
102361
102362   std::string jarg2str = std::string(jarg2);
102363   arg2 = &jarg2str;
102364   {
102365     try {
102366       (arg1)->LoadUrl((std::string const &)*arg2);
102367     } catch (std::out_of_range& e) {
102368       {
102369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102370       };
102371     } catch (std::exception& e) {
102372       {
102373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102374       };
102375     } catch (Dali::DaliException e) {
102376       {
102377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102378       };
102379     } catch (...) {
102380       {
102381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102382       };
102383     }
102384   }
102385 }
102386
102387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
102388   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102389   std::string *arg2;
102390
102391   arg1 = (Dali::Toolkit::WebView *)jarg1;
102392   if (!jarg2) {
102393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102394     return;
102395   }
102396   std::string jarg2str = std::string(jarg2);
102397   arg2 = &jarg2str;
102398   {
102399     try {
102400       (arg1)->LoadHTMLString((std::string const &)*arg2);
102401     } catch (std::out_of_range& e) {
102402       {
102403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102404       };
102405     } catch (std::exception& e) {
102406       {
102407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102408       };
102409     } catch (Dali::DaliException e) {
102410       {
102411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102412       };
102413     } catch (...) {
102414       {
102415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102416       };
102417     }
102418   }
102419 }
102420
102421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
102422   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102423
102424   arg1 = (Dali::Toolkit::WebView *)jarg1;
102425   {
102426     try {
102427       (arg1)->Reload();
102428     } catch (std::out_of_range& e) {
102429       {
102430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102431       };
102432     } catch (std::exception& e) {
102433       {
102434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102435       };
102436     } catch (Dali::DaliException e) {
102437       {
102438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102439       };
102440     } catch (...) {
102441       {
102442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102443       };
102444     }
102445   }
102446 }
102447
102448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
102449   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102450
102451   arg1 = (Dali::Toolkit::WebView *)jarg1;
102452   {
102453     try {
102454       (arg1)->StopLoading();
102455     } catch (std::out_of_range& e) {
102456       {
102457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102458       };
102459     } catch (std::exception& e) {
102460       {
102461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102462       };
102463     } catch (Dali::DaliException e) {
102464       {
102465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102466       };
102467     } catch (...) {
102468       {
102469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102470       };
102471     }
102472   }
102473 }
102474
102475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
102476   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102477
102478   arg1 = (Dali::Toolkit::WebView *)jarg1;
102479   {
102480     try {
102481       (arg1)->Suspend();
102482     } catch (std::out_of_range& e) {
102483       {
102484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102485       };
102486     } catch (std::exception& e) {
102487       {
102488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102489       };
102490     } catch (Dali::DaliException e) {
102491       {
102492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102493       };
102494     } catch (...) {
102495       {
102496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102497       };
102498     }
102499   }
102500 }
102501
102502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
102503   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102504
102505   arg1 = (Dali::Toolkit::WebView *)jarg1;
102506   {
102507     try {
102508       (arg1)->Resume();
102509     } catch (std::out_of_range& e) {
102510       {
102511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102512       };
102513     } catch (std::exception& e) {
102514       {
102515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102516       };
102517     } catch (Dali::DaliException e) {
102518       {
102519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102520       };
102521     } catch (...) {
102522       {
102523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102524       };
102525     }
102526   }
102527 }
102528
102529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
102530   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102531
102532   arg1 = (Dali::Toolkit::WebView *)jarg1;
102533   {
102534     try {
102535       (arg1)->GoBack();
102536     } catch (std::out_of_range& e) {
102537       {
102538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102539       };
102540     } catch (std::exception& e) {
102541       {
102542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102543       };
102544     } catch (Dali::DaliException e) {
102545       {
102546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102547       };
102548     } catch (...) {
102549       {
102550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102551       };
102552     }
102553   }
102554 }
102555
102556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
102557   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102558
102559   arg1 = (Dali::Toolkit::WebView *)jarg1;
102560   {
102561     try {
102562       (arg1)->GoForward();
102563     } catch (std::out_of_range& e) {
102564       {
102565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102566       };
102567     } catch (std::exception& e) {
102568       {
102569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102570       };
102571     } catch (Dali::DaliException e) {
102572       {
102573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102574       };
102575     } catch (...) {
102576       {
102577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102578       };
102579     }
102580   }
102581 }
102582
102583 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
102584   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102585   bool ret;
102586
102587   arg1 = (Dali::Toolkit::WebView *)jarg1;
102588   {
102589     try {
102590       ret = (arg1)->CanGoBack();
102591     } catch (std::out_of_range& e) {
102592       {
102593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102594       };
102595     } catch (std::exception& e) {
102596       {
102597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102598       };
102599     } catch (Dali::DaliException e) {
102600       {
102601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102602       };
102603     } catch (...) {
102604       {
102605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102606       };
102607     }
102608   }
102609   return ret;
102610 }
102611
102612 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
102613   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102614   bool ret;
102615
102616   arg1 = (Dali::Toolkit::WebView *)jarg1;
102617   {
102618     try {
102619       ret = (arg1)->CanGoForward();
102620     } catch (std::out_of_range& e) {
102621       {
102622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102623       };
102624     } catch (std::exception& e) {
102625       {
102626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102627       };
102628     } catch (Dali::DaliException e) {
102629       {
102630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102631       };
102632     } catch (...) {
102633       {
102634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102635       };
102636     }
102637   }
102638   return ret;
102639 }
102640
102641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
102642   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102643   std::string *arg2;
102644
102645   arg1 = (Dali::Toolkit::WebView *)jarg1;
102646   if (!jarg2) {
102647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102648     return;
102649   }
102650   std::string jarg2_str = std::string(jarg2);
102651   arg2 = &jarg2_str;
102652
102653   {
102654     try {
102655       if (jarg3) {
102656         void (*handler)(char*) = (void (*)(char*)) jarg3;
102657         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
102658           handler(SWIG_csharp_string_callback(result.c_str()));
102659         });
102660       } else {
102661         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
102662       }
102663     } catch (std::out_of_range& e) {
102664       {
102665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102666       };
102667     } catch (std::exception& e) {
102668       {
102669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102670       };
102671     } catch (Dali::DaliException e) {
102672       {
102673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102674       };
102675     } catch (...) {
102676       {
102677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102678       };
102679     }
102680   }
102681 }
102682
102683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
102684 {
102685   if (!jarg2) {
102686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102687     return;
102688   }
102689
102690   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102691   std::string exposedObjectName = jarg2;
102692   void (*handler)(char*) = (void (*)(char*)) jarg3;
102693
102694   {
102695     try {
102696       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
102697         handler(SWIG_csharp_string_callback(message.c_str()));
102698       });
102699     } catch (std::out_of_range& e) {
102700       {
102701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102702       };
102703     } catch (std::exception& e) {
102704       {
102705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102706       };
102707     } catch (Dali::DaliException e) {
102708       {
102709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102710       };
102711     } catch (...) {
102712       {
102713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102714       };
102715     }
102716   }
102717 }
102718
102719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
102720   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102721
102722   arg1 = (Dali::Toolkit::WebView *)jarg1;
102723   {
102724     try {
102725       (arg1)->ClearHistory();
102726     } catch (std::out_of_range& e) {
102727       {
102728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102729       };
102730     } catch (std::exception& e) {
102731       {
102732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102733       };
102734     } catch (Dali::DaliException e) {
102735       {
102736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102737       };
102738     } catch (...) {
102739       {
102740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102741       };
102742     }
102743   }
102744 }
102745
102746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
102747   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102748
102749   arg1 = (Dali::Toolkit::WebView *)jarg1;
102750   {
102751     try {
102752       (arg1)->ClearCache();
102753     } catch (std::out_of_range& e) {
102754       {
102755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102756       };
102757     } catch (std::exception& e) {
102758       {
102759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102760       };
102761     } catch (Dali::DaliException e) {
102762       {
102763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102764       };
102765     } catch (...) {
102766       {
102767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102768       };
102769     }
102770   }
102771 }
102772
102773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
102774   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102775
102776   arg1 = (Dali::Toolkit::WebView *)jarg1;
102777   {
102778     try {
102779       (arg1)->ClearCookies();
102780     } catch (std::out_of_range& e) {
102781       {
102782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102783       };
102784     } catch (std::exception& e) {
102785       {
102786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102787       };
102788     } catch (Dali::DaliException e) {
102789       {
102790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102791       };
102792     } catch (...) {
102793       {
102794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102795       };
102796     }
102797   }
102798 }
102799
102800 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
102801     return (Dali::Toolkit::Control *)jarg1;
102802 }
102803
102804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
102805   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102806   SignalConverter::WebViewPageLoadSignal* result = NULL;
102807   {
102808     try {
102809       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
102810     } catch (std::out_of_range& e) {
102811       {
102812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102813       };
102814     } catch (std::exception& e) {
102815       {
102816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102817       };
102818     } catch (Dali::DaliException e) {
102819       {
102820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102821       };
102822     } catch (...) {
102823       {
102824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102825       };
102826     }
102827   }
102828   return (void*) result;
102829 }
102830
102831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
102832   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102833   SignalConverter::WebViewPageLoadSignal* result = NULL;
102834   {
102835     try {
102836       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
102837     } catch (std::out_of_range& e) {
102838       {
102839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102840       };
102841     } catch (std::exception& e) {
102842       {
102843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102844       };
102845     } catch (Dali::DaliException e) {
102846       {
102847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102848       };
102849     } catch (...) {
102850       {
102851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102852       };
102853     }
102854   }
102855   return (void*) result;
102856 }
102857
102858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
102859 {
102860   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102861   {
102862     try {
102863       delete object;
102864     } catch (std::out_of_range& e) {
102865       {
102866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102867       };
102868     } catch (std::exception& e) {
102869       {
102870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102871       };
102872     } catch (Dali::DaliException e) {
102873       {
102874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102875       };
102876     } catch (...) {
102877       {
102878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102879       };
102880     }
102881   }
102882 }
102883
102884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
102885 {
102886   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102887   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102888   {
102889     try {
102890       proxy->Connect(callback);
102891     } catch (std::out_of_range& e) {
102892       {
102893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102894       };
102895     } catch (std::exception& e) {
102896       {
102897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102898       };
102899     } catch (Dali::DaliException e) {
102900       {
102901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102902       };
102903     } catch (...) {
102904       {
102905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102906       };
102907     }
102908   }
102909 }
102910
102911
102912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
102913   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102914   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102915   {
102916     try {
102917       proxy->Disconnect(callback);
102918     } catch (std::out_of_range& e) {
102919       {
102920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102921       };
102922     } catch (std::exception& e) {
102923       {
102924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102925       };
102926     } catch (Dali::DaliException e) {
102927       {
102928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102929       };
102930     } catch (...) {
102931       {
102932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102933       };
102934     }
102935   }
102936 }
102937
102938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
102939   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102940   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
102941   {
102942     try {
102943       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
102944     } catch (std::out_of_range& e) {
102945       {
102946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102947       };
102948     } catch (std::exception& e) {
102949       {
102950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102951       };
102952     } catch (Dali::DaliException e) {
102953       {
102954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102955       };
102956     } catch (...) {
102957       {
102958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102959       };
102960     }
102961   }
102962   return (void*) result;
102963 }
102964
102965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
102966 {
102967   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102968   {
102969     try {
102970       delete object;
102971     } catch (std::out_of_range& e) {
102972       {
102973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102974       };
102975     } catch (std::exception& e) {
102976       {
102977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102978       };
102979     } catch (Dali::DaliException e) {
102980       {
102981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102982       };
102983     } catch (...) {
102984       {
102985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102986       };
102987     }
102988   }
102989 }
102990
102991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
102992 {
102993   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102994   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102995   {
102996     try {
102997       proxy->Connect(callback);
102998     } catch (std::out_of_range& e) {
102999       {
103000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103001       };
103002     } catch (std::exception& e) {
103003       {
103004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103005       };
103006     } catch (Dali::DaliException e) {
103007       {
103008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103009       };
103010     } catch (...) {
103011       {
103012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103013       };
103014     }
103015   }
103016 }
103017
103018
103019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
103020   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103021   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103022   {
103023     try {
103024       proxy->Disconnect(callback);
103025     } catch (std::out_of_range& e) {
103026       {
103027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103028       };
103029     } catch (std::exception& e) {
103030       {
103031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103032       };
103033     } catch (Dali::DaliException e) {
103034       {
103035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103036       };
103037     } catch (...) {
103038       {
103039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103040       };
103041     }
103042   }
103043 }
103044
103045 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
103046   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
103047   char * jresult = SWIG_csharp_string_callback((const char *)result);
103048   return jresult;
103049 }
103050
103051 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
103052   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
103053   return result;
103054 }
103055
103056 #ifdef __cplusplus
103057 }
103058 #endif
103059